Customer Churn em Operadoras de Telecom

Portfólio Thiago Gonçalves Custódio

1. Descrição geral do problema

Com o rápido desenvolvimento da indústria de telecomunicações, os provedores de serviços estão mais inclinados à expansão da base de assinantes. Para atender à necessidade de sobreviver no ambiente competitivo, a retenção dos clientes existentes tornou-se um grande desafio. Afirma-se que o custo de adquirir um novo cliente é muito maior do que o de manter o existente. Portanto, é imperativo que as indústrias de telecomunicações usem análises avançadas para entender o comportamento do consumidor e, por sua vez, prever a associação dos clientes quanto à sua saída ou não da empresa.

Este conjunto de dados é de domínio público e contém informações de nível de cliente para uma empresa de telecomunicações. Vários atributos relacionados aos serviços utilizados são registrados para cada cliente.

Objetivo: Neste projeto iremos utilizar a linguagem Python, para criar um modelo de aprendizagem de máquina que possa prever se um cliente pode ou não cancelar seu plano, e qual a probabilidade de isso ocorrer.

2. Carregando Dados

2.1 Importando bibliotecas necessárias

Começaremos nosso projeto, importanto todas as bilbiotecas necessárias, para a realização das fases iniciais de exploração, e transformação dos dados (Data Munging).

In [1]:
# Importando biblioteca, para ocultar Future Warnings.
import warnings
warnings.simplefilter(action = 'ignore', category = FutureWarning)

# Importando bibliotecas, para a manipulação e exploração dos conjuntos de dados.
import numpy as np
import pandas as pd

# Importando módulos utilitários para Análise Exploratória/Estatística, Pré-processamento/Feature Selection e Modelagem preditiva.
import utilAnaExplor as utlex
import utilScaleTransf as utlst
import utilPcaTransf as utlpca
import utilMachineLearning as utlml

# Importando bibliotecas, para balanceamento de classes e divisão do dataset.
from imblearn.over_sampling import SMOTE

# Importando classes e bibliotecas necessárias para a etapa de pré-processamento dos dados.
from sklearn.preprocessing import MinMaxScaler, PowerTransformer, normalize, LabelEncoder, StandardScaler

# Importando bibliotecas, para a etapa de modelagem preditiva.
from sklearn.feature_selection import SelectKBest, SelectPercentile, mutual_info_classif, f_classif, RFE, chi2
from mlxtend.feature_selection import SequentialFeatureSelector as SFS
import xgboost as xgb
from sklearn.ensemble import RandomForestClassifier, ExtraTreesClassifier, AdaBoostClassifier, GradientBoostingClassifier
import xgboost as xgb
from sklearn import tree
from sklearn.svm import SVC
from sklearn.naive_bayes import GaussianNB
from sklearn.tree import DecisionTreeClassifier
from sklearn.neighbors import KNeighborsClassifier
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import KFold, cross_val_score
from sklearn.discriminant_analysis import LinearDiscriminantAnalysis
from sklearn.ensemble import RandomForestClassifier, ExtraTreesClassifier, AdaBoostClassifier, GradientBoostingClassifier

# Importando classe, para fazer a busca dos melhores parâmetros, a serem utilizados em cada um dos modelos treinados.
from sklearn.model_selection import GridSearchCV

# Importando classes, para calcular as métricas de avaliação dos modelos preditivos.
from sklearn.metrics import accuracy_score, balanced_accuracy_score, average_precision_score, precision_score
from sklearn.metrics import recall_score, f1_score, roc_auc_score, cohen_kappa_score

# Versões dos pacotes usados neste jupyter notebook
%reload_ext watermark
%watermark -a "Thiago Gonçalves Custódio" --iversions
Author: Thiago Gonçalves Custódio

pandas : 1.2.2
xgboost: 1.5.0
numpy  : 1.20.1
sklearn: 1.0.1

2.2 Carregando Dados

In [2]:
# Carregando dados de treino.
dataTrain = pd.read_csv('datasets/projeto4_telecom_treino.csv')
In [3]:
# Exibindo as primeiras linhas do DataFrame.
dataTrain.head()
Out[3]:
Unnamed: 0 state account_length area_code international_plan voice_mail_plan number_vmail_messages total_day_minutes total_day_calls total_day_charge ... total_eve_calls total_eve_charge total_night_minutes total_night_calls total_night_charge total_intl_minutes total_intl_calls total_intl_charge number_customer_service_calls churn
0 1 KS 128 area_code_415 no yes 25 265.1 110 45.07 ... 99 16.78 244.7 91 11.01 10.0 3 2.70 1 no
1 2 OH 107 area_code_415 no yes 26 161.6 123 27.47 ... 103 16.62 254.4 103 11.45 13.7 3 3.70 1 no
2 3 NJ 137 area_code_415 no no 0 243.4 114 41.38 ... 110 10.30 162.6 104 7.32 12.2 5 3.29 0 no
3 4 OH 84 area_code_408 yes no 0 299.4 71 50.90 ... 88 5.26 196.9 89 8.86 6.6 7 1.78 2 no
4 5 OK 75 area_code_415 yes no 0 166.7 113 28.34 ... 122 12.61 186.9 121 8.41 10.1 3 2.73 3 no

5 rows × 21 columns

In [4]:
# Carregando dados de teste.
dataTest = pd.read_csv('datasets/projeto4_telecom_teste.csv')
In [5]:
# Exibindo as primeiras linhas do DataFrame.
dataTest.head()
Out[5]:
Unnamed: 0 state account_length area_code international_plan voice_mail_plan number_vmail_messages total_day_minutes total_day_calls total_day_charge ... total_eve_calls total_eve_charge total_night_minutes total_night_calls total_night_charge total_intl_minutes total_intl_calls total_intl_charge number_customer_service_calls churn
0 1 HI 101 area_code_510 no no 0 70.9 123 12.05 ... 73 18.01 236.0 73 10.62 10.6 3 2.86 3 no
1 2 MT 137 area_code_510 no no 0 223.6 86 38.01 ... 139 20.81 94.2 81 4.24 9.5 7 2.57 0 no
2 3 OH 103 area_code_408 no yes 29 294.7 95 50.10 ... 105 20.17 300.3 127 13.51 13.7 6 3.70 1 no
3 4 NM 99 area_code_415 no no 0 216.8 123 36.86 ... 88 10.74 220.6 82 9.93 15.7 2 4.24 1 no
4 5 SC 108 area_code_415 no no 0 197.4 78 33.56 ... 101 10.54 204.5 107 9.20 7.7 4 2.08 2 no

5 rows × 21 columns

3. Data Munging - Preparando dados para a análise exploratória

3.1 Criando funções auxiliares

Iremos definir algumas funções, para facilitar a execução das etapas de Data Munging.

In [6]:
# Definindo uma função, para converter variáveis para o tipo categórico, e criar suas respectivas versões dummy.
def categoryToDummyVariables(data, columnsName):

    # Criando um dicionário vazio.
    newTypes = dict()
    
    # Criando o nome das variáveis dummy.
    newColumnsName = [n + '_dummy' for n in columnsName]

    # Definindo que cada variável especificada, deve ser convertida para o tipo de dado categórico.
    for i in range(0, len(columnsName)):
        newTypes.update({columnsName[i]: 'category'}) 

    # Convertendo o tipo de dado das variáveis especificadas.
    data = data.astype (newTypes)

    # Criando variáveis dummy.
    for i in range(0, len(columnsName)):
        data[newColumnsName[i]] = data[columnsName[i]].cat.codes

    # Retornando o DataFrame modificado.    
    return data
In [7]:
# Definindo uma função, para realizar as tarefas de Data Munging, necessárias para o conjunto de dados em análise.
def organizeData(data):
    
    # Extraindo o código de área da variável area_code.
    data['area_code'] = data['area_code'].apply(lambda e: e.split('_')[2]).astype('category')
    
    # Criando variáveis dummy para o conjunto de dados.
    data = categoryToDummyVariables(data = data, columnsName = data.select_dtypes(include = object).columns)

    # Eliminando a variável de índice do conjunto de dados.
    data = data.drop(columns = data.columns[0], axis = 1)

    # Retornando o DataFrame modificado.    
    return data

3.2 Visão geral dos dados

3.2.1 De treino

In [8]:
# Verificando as dimensões do dataset de treino.
dataTrain.shape
Out[8]:
(3333, 21)

Verificamos a existência de 21 variáveis, e 3.333 observações dentro do dataset de treino.

In [9]:
# Verificando o número de registros duplicados.
dataTrain.duplicated().sum()
Out[9]:
0

Não há registros duplicados no dataset de treino.

In [10]:
# Verificando o número de NAs existentes dentro do dataset de treino.
dataTrain.isna().sum()
Out[10]:
Unnamed: 0                       0
state                            0
account_length                   0
area_code                        0
international_plan               0
voice_mail_plan                  0
number_vmail_messages            0
total_day_minutes                0
total_day_calls                  0
total_day_charge                 0
total_eve_minutes                0
total_eve_calls                  0
total_eve_charge                 0
total_night_minutes              0
total_night_calls                0
total_night_charge               0
total_intl_minutes               0
total_intl_calls                 0
total_intl_charge                0
number_customer_service_calls    0
churn                            0
dtype: int64

Não foi detectado nenhum valor NA dentro do conjunto de dados.

In [11]:
# Verificando o tipo de dados das variáveis do dataset.
dataTrain.dtypes.value_counts()
Out[11]:
float64    8
int64      8
object     5
dtype: int64
In [12]:
# Contabilizando o número de valores únicos, em cada variável do dataset de treino.
info = dataTrain.nunique().sort_values()

# Determinando o tipo de dado, de cada uma das variáveis, do dataset de treino.
info = pd.DataFrame(info.values, index = info.index, columns = ['NUniques'])

# Atribuindo informações, sobre o tipo de dado das variáveis, ao DataFrame.
info['dtypes'] = dataTrain.dtypes

# Exibindo DataFrame.
info
Out[12]:
NUniques dtypes
churn 2 object
international_plan 2 object
voice_mail_plan 2 object
area_code 3 object
number_customer_service_calls 10 int64
total_intl_calls 21 int64
number_vmail_messages 46 int64
state 51 object
total_day_calls 119 int64
total_night_calls 120 int64
total_eve_calls 123 int64
total_intl_charge 162 float64
total_intl_minutes 162 float64
account_length 212 int64
total_night_charge 933 float64
total_eve_charge 1440 float64
total_night_minutes 1591 float64
total_eve_minutes 1611 float64
total_day_minutes 1667 float64
total_day_charge 1667 float64
Unnamed: 0 3333 int64

3.2.2 De teste

In [13]:
# Verificando as dimensões do dataset de teste.
dataTest.shape
Out[13]:
(1667, 21)

Verificamos a existência de 21 variáveis, e 1.667 observações dentro do dataset de teste.

In [14]:
# Verificando o número de IDs duplicados.
dataTest.duplicated().sum()
Out[14]:
0

Não há registros duplicados no dataset de teste.

In [15]:
# Verificando o número de NAs existentes dentro do dataset de teste.
dataTest.isna().sum()
Out[15]:
Unnamed: 0                       0
state                            0
account_length                   0
area_code                        0
international_plan               0
voice_mail_plan                  0
number_vmail_messages            0
total_day_minutes                0
total_day_calls                  0
total_day_charge                 0
total_eve_minutes                0
total_eve_calls                  0
total_eve_charge                 0
total_night_minutes              0
total_night_calls                0
total_night_charge               0
total_intl_minutes               0
total_intl_calls                 0
total_intl_charge                0
number_customer_service_calls    0
churn                            0
dtype: int64

Não foi detectado nenhum valor NA dentro do conjunto de dados.

In [16]:
# Verificando o tipo de dados das variáveis do dataset.
dataTest.dtypes.value_counts()
Out[16]:
float64    8
int64      8
object     5
dtype: int64
In [17]:
# Contabilizando o número de valores únicos, em cada variável do dataset de treino.
info = dataTest.nunique().sort_values()

# Determinando o tipo de dado, de cada uma das variáveis, do dataset de treino.
info = pd.DataFrame(info.values, index = info.index, columns = ['NUniques'])

# Atribuindo informações, sobre o tipo de dado das variáveis, ao DataFrame.
info['dtypes'] = dataTest.dtypes

# Exibindo DataFrame.
info
Out[17]:
NUniques dtypes
churn 2 object
international_plan 2 object
voice_mail_plan 2 object
area_code 3 object
number_customer_service_calls 8 int64
total_intl_calls 19 int64
number_vmail_messages 41 int64
state 51 object
total_day_calls 109 int64
total_eve_calls 109 int64
total_night_calls 121 int64
total_intl_charge 148 float64
total_intl_minutes 148 float64
account_length 198 int64
total_night_charge 743 float64
total_eve_charge 993 float64
total_eve_minutes 1088 float64
total_night_minutes 1093 float64
total_day_charge 1098 float64
total_day_minutes 1098 float64
Unnamed: 0 1667 int64

3.3 Alterando tipos de dados das variáveis dos datasets

Iremos extrair o código de área para a variável area_code e convertê-la para o tipo de dado numérico. Também criaremos variáveis dummy para aquelas que forem do tipo categórico. Por fim, eliminaremos a coluna de índices do conjunto de dados.

Aplicaremos este processo para os dados de treino e de teste.

In [18]:
# Limpando e organizando o conjunto de dados de treino.
dataTrain = organizeData(data = dataTrain)
In [19]:
# Limpando e organizando o conjunto de dados de teste.
dataTest = organizeData(data = dataTest)

4. Análise exploratória dos dados

Medidas de Assimetria e Curtose

O coeficente de Assimetria (Skewness), indica como os dados estão distribuídos, e para interpretar seu resultado podemos olhar a tabela a seguir:

Índice de Assimetria Descrição:
SK ≈ 0 Os dados são simétricos. Tanto a cauda do lado direito, quanto a do lado esquerdo da função densidade de probabilidade, são iguais;
SK < 0 A assimetria é negativa. A cauda do lado esquerdo da função densidade de probabilidade, é maior que a do lado direito e;
SK > 0 A assimetria é positiva. A cauda do lado direito da função densidade de probabilidade, é maior que a do lado esquerdo.

O coeficiente de Curtose (Kurtosis), é uma medida que caracteriza o achatamento da curva da função de distribuição, e para interpretar seu resultado, podemos olhar a tabela a seguir:

Índice de Curtose Descrição:
CK ≈ 0 A distribuição é normal, e é chamada de Curtose Mesocúrtica;
CK < 0 A Cauda é mais leve que a normal. Para um coeficiente de Curtose negativo, tem-se uma Curtose Platicúrtica e;
CK > 0 A Cauda é mais pesada que a normal. Para um coeficiente de Curtose positivo, tem-se uma Curtose Leptocúrtica.

4.1 Explorando a distribuição da variável target

4.1.1 Variável churn

In [20]:
# Definindo o nome da variável a ser analisada.
col = 'churn'

# Definindo a descrição da variável nos gráficos.
label = 'Churn'

# Contabilizando a frequência absoluta, de cada categoria presente na variável especificada.
dataCounts = dataTrain[col].value_counts()

# Plotando um gráfico de barras para a variável especificada.
utlex.plotBar (
    data  = dataCounts,
    title = 'Frequência absoluta das categorias da Feature ' + col, 
    yaxis = 'Frequência Absoluta', 
    xaxis = label
)
In [21]:
# Plotando um gráfico de pizza para a variável especificada.
utlex.plotPie (
    data  = dataCounts, 
    title = 'Frequência relativa das categorias da feature ' + col
)

Apenas 14,5 % dos registros referem-se a clientes que efetuaram o churn. Nossa variável target esta desbalanceada, trataremos tal desvio mais a frente.

4.2 Explorando a distribuição de cada Feature a partir da variável Target

4.2.1 Variável state

In [22]:
# Definindo o nome da variável a ser analisada.
col = 'state'

# Definindo o nome da variável Target.
target = 'churn'

# Definindo a descrição da variável nos gráficos.
label = 'Estados'

# Capturando variáveis especificadas do Dataset.
data = dataTrain[[col, target]]

# Criando uma variável count para contabilizar as ocorrências de cada registro.
data['count'] = 1

# Agrupando dados e contabilizando o número de ocorrências.
data = data.groupby(by = [target, col]).sum()

# Reorganizando DataFrame. 
data = data.reset_index()

# Plotando um gráfico de barras para a variável especificada.
utlex.plotBar (
    data   = data,
    col    = col,
    target = target,
    title  = 'Churn dos clientes por ' + label,
    yaxis  = 'Frequência Absoluta',
    xaxis  = label, 
    kind   = 'groups'
)

Os estados do Texas (TX), New Jersey (NJ) e Maryland (MD) são os que apresentam as maiores quantidades de registros de clientes que realizaram o churn.

4.2.2 Variável account_length

In [23]:
# Definindo o nome da variável a ser analisada.
col = 'account_length'

# Definindo o nome da variável Target.
target = 'churn'

# Definindo a descrição da variável nos gráficos.
label = 'Tamanho da Conta'

# Capturando variáveis especificadas do Dataset.
data = dataTrain[[col, target]]

# Criando uma variável count para contabilizar as ocorrências de cada registro.
data['count'] = 1

# Agrupando dados e contabilizando o número de ocorrências.
data = data.groupby(by = [target, col]).sum()

# Reorganizando DataFrame. 
data = data.reset_index()

# Plotando um gráfico de histograma para a variável especificada.
utlex.plotHist (
    data   = dataTrain[[col, target]],
    title  = 'Histograma para a variável ' + col,
    xaxis  = label,
    yaxis  = 'Frequência Absoluta',
    col    = col,
    target = target,
    groups = True
)
In [24]:
# Criando um gráfico de Densidade para a variável especificada.
utlex.plotDensity (
    data   = dataTrain[[col, target]], 
    title  = 'Gráfico de Densidade para a variável ' + col, 
    xaxis  = label,
    col    = col,
    target = target,
    group  = True
)

A distribuição do tamanho da conta, para os indivíduos que fizeram ou não o churn, é aproximandamente igual.

In [25]:
# Plotando um gráfico de boxplot para a variável especificada.
utlex.plotBoxplot (
    data   = dataTrain[[col, target]],
    title  = 'Boxplot para a variável ' + col,
    yaxis  = label,
    xaxis  = target.capitalize(),
    col    = col,
    target = target,
    kind   = 'groups'
)

O tamanho mediano, das contas dos indivíduos que realizaram o churn, é ligeiramente maior do que o daqueles que não o efeturam.

In [26]:
# Calculando algumas estatísticas para a variável especificada.
utlex.varStats(col = col, data = dataTrain, target = target)
Out[26]:
min Q1 Median Mean Q3 SD Sk Ck
churn
no 1 73.0 100 100.793684 127.0 39.88235 0.090523 -0.135657
yes 1 76.0 103 102.664596 127.0 39.46782 0.137132 0.043640

Destacamos que:

  • A média e a mediana, do tamanho da conta dos grupos, apresentam valores ligeiramente diferentes;
  • O coeficiente de assimetria (Sk), evidência que o grupo dos clientes que efetuaram o churn, tem uma assimetria à direita ligeiramente maior;
  • O coeficiente de curtose (Ck), evidência que o grupo dos clientes que efetuaram o churn, é aproximadamente mais normal.

4.2.3 Variável area_code

In [27]:
# Definindo o nome da variável a ser analisada.
col = 'area_code'

# Definindo o nome da variável Target.
target = 'churn'

# Definindo a descrição da variável nos gráficos.
label = 'Código de Área'

# Capturando variáveis especificadas do Dataset.
data = dataTrain[[col, target]]

# Criando uma variável count para contabilizar as ocorrências de cada registro.
data['count'] = 1

# Agrupando dados e contabilizando o número de ocorrências.
data = data.groupby(by = [target, col]).sum()

# Reorganizando DataFrame. 
data = data.reset_index()

# Transformando variável alvo em String.
data[col] = data[col].apply(lambda c: str(c) + ' Code')

# Plotando um gráfico de barras para a variável especificada.
utlex.plotBar (
    data   = data,
    col    = col,
    target = target,
    title  = 'Churn dos clientes por ' + label,
    yaxis  = 'Frequência Absoluta',
    xaxis  = label, 
    kind   = 'groups'
)

O código de área 415, é o que apresenta o maior número de registros para os clientes que realizaram o churn.

4.2.4 Variável international_plan

In [28]:
# Definindo o nome da variável a ser analisada.
col = 'international_plan'

# Definindo o nome da variável Target.
target = 'churn'

# Definindo a descrição da variável nos gráficos.
label = 'Plano Internacional'

# Capturando variáveis especificadas do Dataset.
data = dataTrain[[col, target]]

# Criando uma variável count para contabilizar as ocorrências de cada registro.
data['count'] = 1

# Agrupando dados e contabilizando o número de ocorrências.
data = data.groupby(by = [target, col]).sum()

# Reorganizando DataFrame. 
data = data.reset_index()

# Capitalizando valores da variável alvo.
data[col] = data[col].apply(lambda c: c.capitalize())

# Plotando um gráfico de barras para a variável especificada.
utlex.plotBar (
    data   = data,
    col    = col,
    target = target,
    title  = 'Churn dos clientes por ' + label,
    yaxis  = 'Frequência Absoluta',
    xaxis  = label, 
    kind   = 'groups'
)

A proporção de clientes que utilizam o plano internacional, e fizeram ou não o churn, é aproximadamente igual.

4.2.5 Variável voice_mail_plan

In [29]:
# Definindo o nome da variável a ser analisada.
col = 'voice_mail_plan'

# Definindo o nome da variável Target.
target = 'churn'

# Definindo a descrição da variável nos gráficos.
label = 'Plano de Correio de Voz'

# Capturando variáveis especificadas do Dataset.
data = dataTrain[[col, target]]

# Criando uma variável count para contabilizar as ocorrências de cada registro.
data['count'] = 1

# Agrupando dados e contabilizando o número de ocorrências.
data = data.groupby(by = [target, col]).sum()

# Reorganizando DataFrame. 
data = data.reset_index()

# Capitalizando valores da variável alvo.
data[col] = data[col].apply(lambda c: c.capitalize())

# Plotando um gráfico de barras para a variável especificada.
utlex.plotBar (
    data   = data,
    col    = col,
    target = target,
    title  = 'Churn dos clientes por ' + label,
    yaxis  = 'Frequência Absoluta',
    xaxis  = label, 
    kind   = 'groups'
)

Os clientes que utilizam o plano de correio de voz, predominantemente, não realizam o churn.

4.2.6 Variável number_vmail_messages

In [30]:
# Definindo o nome da variável a ser analisada.
col = 'number_vmail_messages'

# Definindo o nome da variável Target.
target = 'churn'

# Definindo a descrição da variável nos gráficos.
label = 'Número de mensagens vmail'

# Capturando variáveis especificadas do Dataset.
data = dataTrain[[col, target]]

# Criando uma variável count para contabilizar as ocorrências de cada registro.
data['count'] = 1

# Agrupando dados e contabilizando o número de ocorrências.
data = data.groupby(by = [target, col]).sum()

# Reorganizando DataFrame. 
data = data.reset_index()

# Plotando um gráfico de histograma para a variável especificada.
utlex.plotHist (
    data   = dataTrain[[col, target]],
    title  = 'Histograma para a variável ' + col,
    xaxis  = label,
    yaxis  = 'Frequência Absoluta',
    col    = col,
    target = target,
    groups = True
)

Os clientes que efeturam o churn, predominantemente, não enviam mensagens vmail.

In [31]:
# Criando um gráfico de Densidade para a variável especificada.
utlex.plotDensity (
    data   = dataTrain[[col, target]], 
    title  = 'Gráfico de Densidade para a variável ' + col, 
    xaxis  = label,
    col    = col,
    target = target,
    group  = True
)
In [32]:
# Plotando um gráfico de boxplot para a variável especificada.
utlex.plotBoxplot (
    data   = dataTrain[[col, target]],
    title  = 'Boxplot para a variável ' + col,
    yaxis  = label,
    xaxis  = target.capitalize(),
    col    = col,
    target = target,
    kind   = 'groups'
)

O grupo de indivíduos que não realiza o churn, apresenta uma variação maior. Também observamos, que aqueles indivíduos que realizam o churn e utilizam as mensagens vmail, são outliers.

In [33]:
# Calculando algumas estatísticas para a variável especificada.
utlex.varStats(col = col, data = dataTrain, target = target)
Out[33]:
min Q1 Median Mean Q3 SD Sk Ck
churn
no 0 0.0 0 8.604561 22.0 13.913125 1.167435 -0.292254
yes 0 0.0 0 5.115942 0.0 11.860138 2.040412 2.524606

Destacamos que:

  • A média do tamanho da conta dos grupos, apresenta valores diferentes;
  • O coeficiente de assimetria (Sk), evidência que o grupo dos clientes que efetuaram o churn, tem uma assimetria à direita maior;
  • O coeficiente de curtose (Ck), evidência que o grupo dos clientes que efetuaram o churn, apresenta uma calda mais pesada que a normal.

4.2.7 Variável total_day_minutes

In [34]:
# Definindo o nome da variável a ser analisada.
col = 'total_day_minutes'

# Definindo o nome da variável Target.
target = 'churn'

# Definindo a descrição da variável nos gráficos.
label = 'Total de minutos Diários'

# Capturando variáveis especificadas do Dataset.
data = dataTrain[[col, target]]

# Criando uma variável count para contabilizar as ocorrências de cada registro.
data['count'] = 1

# Agrupando dados e contabilizando o número de ocorrências.
data = data.groupby(by = [target, col]).sum()

# Reorganizando DataFrame. 
data = data.reset_index()

# Plotando um gráfico de histograma para a variável especificada.
utlex.plotHist (
    data   = dataTrain[[col, target]],
    title  = 'Histograma para a variável ' + col,
    xaxis  = label,
    yaxis  = 'Frequência Absoluta',
    col    = col,
    target = target,
    groups = True
)

O grupo dos clientes que não realizaram o churn, aparenta ter uma distribuição normal, para o total de minutos diários.

In [35]:
# Criando um gráfico de Densidade para a variável especificada.
utlex.plotDensity (
    data   = dataTrain[[col, target]], 
    title  = 'Gráfico de Densidade para a variável ' + col, 
    xaxis  = label,
    col    = col,
    target = target,
    group  = True
)

O grupo dos clientes que realizaram o churn, aparenta ter duas modas: uma em torno de 160 minutos e outra em torno de 265 minutos.

In [36]:
# Plotando um gráfico de boxplot para a variável especificada.
utlex.plotBoxplot (
    data   = dataTrain[[col, target]],
    title  = 'Boxplot para a variável ' + col,
    yaxis  = label,
    xaxis  = target.capitalize(),
    col    = col,
    target = target,
    kind   = 'groups'
)

O grupo de indivíduos que realizaram o churn, apresentam um total de minutos diários maior.

In [37]:
# Calculando algumas estatísticas para a variável especificada.
utlex.varStats(col = col, data = dataTrain, target = target)
Out[37]:
min Q1 Median Mean Q3 SD Sk Ck
churn
no 0.0 142.825 177.2 175.175754 210.30 50.181655 -0.226378 -0.006024
yes 0.0 153.250 217.6 206.914079 265.95 68.997792 -0.199223 -0.813099

Destacamos que:

  • A média e a mediana, do total de minutos diários dos grupos, apresenta valores diferentes;
  • O coeficiente de assimetria (Sk), evidência que o grupo dos clientes que não efetuaram o churn, tem uma assimetria à esquerda maior;
  • O coeficiente de curtose (Ck), evidência que o grupo dos clientes que efetuaram o churn, apresenta uma calda mais leve que a normal.

4.2.8 Variável total_day_calls

In [38]:
# Definindo o nome da variável a ser analisada.
col = 'total_day_calls'

# Definindo o nome da variável Target.
target = 'churn'

# Definindo a descrição da variável nos gráficos.
label = 'Total de chamadas diárias'

# Capturando variáveis especificadas do Dataset.
data = dataTrain[[col, target]]

# Criando uma variável count para contabilizar as ocorrências de cada registro.
data['count'] = 1

# Agrupando dados e contabilizando o número de ocorrências.
data = data.groupby(by = [target, col]).sum()

# Reorganizando DataFrame. 
data = data.reset_index()

# Plotando um gráfico de histograma para a variável especificada.
utlex.plotHist (
    data   = dataTrain[[col, target]],
    title  = 'Histograma para a variável ' + col,
    xaxis  = label,
    yaxis  = 'Frequência Absoluta',
    col    = col,
    target = target,
    groups = True
)

O total de chamadas diárias, parece ter uma distribuição aproximadamente normal, para o grupo de clientes que não realizaram o churn.

In [39]:
# Criando um gráfico de Densidade para a variável especificada.
utlex.plotDensity (
    data   = dataTrain[[col, target]], 
    title  = 'Gráfico de Densidade para a variável ' + col, 
    xaxis  = label,
    col    = col,
    target = target,
    group  = True
)

O total de chamadas diárias, para o grupo dos indivíduos que realizaram o churn, aparenta ser levemente maior.

In [40]:
# Plotando um gráfico de boxplot para a variável especificada.
utlex.plotBoxplot (
    data   = dataTrain[[col, target]],
    title  = 'Boxplot para a variável ' + col,
    yaxis  = label,
    xaxis  = target.capitalize(),
    col    = col,
    target = target,
    kind   = 'groups'
)

Há mais outliers no grupo dos clientes que não realizaram o churn.

In [41]:
# Calculando algumas estatísticas para a variável especificada.
utlex.varStats(col = col, data = dataTrain, target = target)
Out[41]:
min Q1 Median Mean Q3 SD Sk Ck
churn
no 0 87.0 100 100.283158 114.0 19.801157 -0.063296 0.124995
yes 0 87.5 103 101.335404 116.5 21.582307 -0.353392 0.709753

Destacamos que:

  • A média e a mediana, do total de chamadas diárias dos grupos, apresenta valores diferentes;
  • O coeficiente de assimetria (Sk), evidência que o grupo dos clientes que efetuaram o churn, tem uma assimetria à esquerda maior;
  • O coeficiente de curtose (Ck), evidência que o grupo dos clientes que efetuaram o churn, apresenta uma calda mais pesada que a normal.

4.2.9 Variável total_day_charge

In [42]:
# Definindo o nome da variável a ser analisada.
col = 'total_day_charge'

# Definindo o nome da variável Target.
target = 'churn'

# Definindo a descrição da variável nos gráficos.
label = 'Carga diária Total'

# Capturando variáveis especificadas do Dataset.
data = dataTrain[[col, target]]

# Criando uma variável count para contabilizar as ocorrências de cada registro.
data['count'] = 1

# Agrupando dados e contabilizando o número de ocorrências.
data = data.groupby(by = [target, col]).sum()

# Reorganizando DataFrame. 
data = data.reset_index()

# Plotando um gráfico de histograma para a variável especificada.
utlex.plotHist (
    data   = dataTrain[[col, target]],
    title  = 'Histograma para a variável ' + col,
    xaxis  = label,
    yaxis  = 'Frequência Absoluta',
    col    = col,
    target = target,
    groups = True
)

A carga diária total, do grupo de indivíduos que não realizaram o churn, aparenta ter uma distribuição normal.

In [43]:
# Criando um gráfico de Densidade para a variável especificada.
utlex.plotDensity (
    data   = dataTrain[[col, target]], 
    title  = 'Gráfico de Densidade para a variável ' + col, 
    xaxis  = label,
    col    = col,
    target = target,
    group  = True
)

A carga diária total, do grupo de indivíduos que realizaram o churn, aparenta ter duas modas: uma em torno de 26 e outra em torno de 45.

In [44]:
# Plotando um gráfico de boxplot para a variável especificada.
utlex.plotBoxplot (
    data   = dataTrain[[col, target]],
    title  = 'Boxplot para a variável ' + col,
    yaxis  = label,
    xaxis  = target.capitalize(),
    col    = col,
    target = target,
    kind   = 'groups'
)

A variação e a mediana da carga diária total, do grupo de indivíduos que realizaram o churn, é maior.

In [45]:
# Calculando algumas estatísticas para a variável especificada.
utlex.varStats(col = col, data = dataTrain, target = target)
Out[45]:
min Q1 Median Mean Q3 SD Sk Ck
churn
no 0.0 24.2825 30.12 29.780421 35.75 8.530835 -0.226405 -0.005913
yes 0.0 26.0550 36.99 35.175921 45.21 11.729710 -0.199209 -0.813006

Destacamos que:

  • A média e a mediana, do total de chamadas diárias dos grupos, apresenta valores diferentes;
  • O coeficiente de assimetria (Sk), evidência que o grupo dos clientes que não efetuaram o churn, tem uma assimetria à esquerda maior;
  • O coeficiente de curtose (Ck), evidência que o grupo dos clientes que efetuaram o churn, apresenta uma calda mais leve que a normal.

4.2.10 Variável total_eve_minutes

In [46]:
# Definindo o nome da variável a ser analisada.
col = 'total_eve_minutes'

# Definindo o nome da variável Target.
target = 'churn'

# Definindo a descrição da variável nos gráficos.
label = 'Total de minutos à Tarde'

# Capturando variáveis especificadas do Dataset.
data = dataTrain[[col, target]]

# Criando uma variável count para contabilizar as ocorrências de cada registro.
data['count'] = 1

# Agrupando dados e contabilizando o número de ocorrências.
data = data.groupby(by = [target, col]).sum()

# Reorganizando DataFrame. 
data = data.reset_index()

# Plotando um gráfico de histograma para a variável especificada.
utlex.plotHist (
    data   = dataTrain[[col, target]],
    title  = 'Histograma para a variável ' + col,
    xaxis  = label,
    yaxis  = 'Frequência Absoluta',
    col    = col,
    target = target,
    groups = True
)

O total de minutos à tarde, para o grupo de clientes que não realizaram o churn, aparenta ter uma distribuição normal.

In [47]:
# Criando um gráfico de Densidade para a variável especificada.
utlex.plotDensity (
    data   = dataTrain[[col, target]], 
    title  = 'Gráfico de Densidade para a variável ' + col, 
    xaxis  = label,
    col    = col,
    target = target,
    group  = True
)

O total de minutos à tarde, para o grupo de clientes que realizaram o churn, aparenta ter um valor mediano maior.

In [48]:
# Plotando um gráfico de boxplot para a variável especificada.
utlex.plotBoxplot (
    data   = dataTrain[[col, target]],
    title  = 'Boxplot para a variável ' + col,
    yaxis  = label,
    xaxis  = target.capitalize(),
    col    = col,
    target = target,
    kind   = 'groups'
)

O grupo de clientes que não realizaram o churn, apresenta mais outliers.

In [49]:
# Calculando algumas estatísticas para a variável especificada.
utlex.varStats(col = col, data = dataTrain, target = target)
Out[49]:
min Q1 Median Mean Q3 SD Sk Ck
churn
no 0.0 164.5 199.6 199.043298 233.20 50.292175 -0.043140 0.032215
yes 70.9 177.1 211.3 212.410145 249.45 51.728910 0.033129 -0.103768

Destacamos que:

  • A média e a mediana, do total de minutos à tarde dos grupos, apresenta valores diferentes;
  • O coeficiente de assimetria (Sk), evidência que o grupo dos clientes que não efetuaram o churn, tem uma assimetria à esquerda maior;
  • O coeficiente de curtose (Ck), evidência que o grupo dos clientes que efetuaram o churn, apresenta uma calda mais leve que a normal.

4.2.11 Variável total_eve_calls

In [50]:
# Definindo o nome da variável a ser analisada.
col = 'total_eve_calls'

# Definindo o nome da variável Target.
target = 'churn'

# Definindo a descrição da variável nos gráficos.
label = 'Ligações totais à Tarde'

# Capturando variáveis especificadas do Dataset.
data = dataTrain[[col, target]]

# Criando uma variável count para contabilizar as ocorrências de cada registro.
data['count'] = 1

# Agrupando dados e contabilizando o número de ocorrências.
data = data.groupby(by = [target, col]).sum()

# Reorganizando DataFrame. 
data = data.reset_index()

# Plotando um gráfico de histograma para a variável especificada.
utlex.plotHist (
    data   = dataTrain[[col, target]],
    title  = 'Histograma para a variável ' + col,
    xaxis  = label,
    yaxis  = 'Frequência Absoluta',
    col    = col,
    target = target,
    groups = True
)

Os dois grupos de clientes, aparentam ter uma distribuição normal, para o número de ligações totais à tarde.

In [51]:
# Criando um gráfico de Densidade para a variável especificada.
utlex.plotDensity (
    data   = dataTrain[[col, target]], 
    title  = 'Gráfico de Densidade para a variável ' + col, 
    xaxis  = label,
    col    = col,
    target = target,
    group  = True
)

A distribuição de densidade dos grupos é muito semelhante.

In [52]:
# Plotando um gráfico de boxplot para a variável especificada.
utlex.plotBoxplot (
    data   = dataTrain[[col, target]],
    title  = 'Boxplot para a variável ' + col,
    yaxis  = label,
    xaxis  = target.capitalize(),
    col    = col,
    target = target,
    kind   = 'groups'
)

O grupo de clientes que não realizaram o churn apresenta mais outliers.

In [53]:
# Calculando algumas estatísticas para a variável especificada.
utlex.varStats(col = col, data = dataTrain, target = target)
Out[53]:
min Q1 Median Mean Q3 SD Sk Ck
churn
no 0 87.0 100 100.038596 114.0 19.958414 -0.069217 0.246968
yes 48 87.0 101 100.561077 114.0 19.724711 0.029856 -0.073037

Destacamos que:

  • A média e a mediana, do total de minutos à tarde dos grupos, apresenta valores próximos;
  • O coeficiente de assimetria (Sk), evidência que o grupo dos clientes que não efetuaram o churn, tem uma assimetria à esquerda maior;
  • O coeficiente de curtose (Ck), evidência que o grupo dos clientes que não efetuaram o churn, apresenta uma calda mais pesada que a normal.

4.2.12 Variável total_eve_charge

In [54]:
# Definindo o nome da variável a ser analisada.
col = 'total_eve_charge'

# Definindo o nome da variável Target.
target = 'churn'

# Definindo a descrição da variável nos gráficos.
label = 'Carga total à Tarde'

# Capturando variáveis especificadas do Dataset.
data = dataTrain[[col, target]]

# Criando uma variável count para contabilizar as ocorrências de cada registro.
data['count'] = 1

# Agrupando dados e contabilizando o número de ocorrências.
data = data.groupby(by = [target, col]).sum()

# Reorganizando DataFrame. 
data = data.reset_index()

# Plotando um gráfico de histograma para a variável especificada.
utlex.plotHist (
    data   = dataTrain[[col, target]],
    title  = 'Histograma para a variável ' + col,
    xaxis  = label,
    yaxis  = 'Frequência Absoluta',
    col    = col,
    target = target,
    groups = True
)
In [55]:
# Criando um gráfico de Densidade para a variável especificada.
utlex.plotDensity (
    data   = dataTrain[[col, target]], 
    title  = 'Gráfico de Densidade para a variável ' + col, 
    xaxis  = label,
    col    = col,
    target = target,
    group  = True
)

A carga total à tarde dos grupos, parece ser normalmente distribuida.

In [56]:
# Plotando um gráfico de boxplot para a variável especificada.
utlex.plotBoxplot (
    data   = dataTrain[[col, target]],
    title  = 'Boxplot para a variável ' + col,
    yaxis  = label,
    xaxis  = target.capitalize(),
    col    = col,
    target = target,
    kind   = 'groups'
)

O grupo de clientes que não realizaram o churn, apresenta mais outliers.

In [57]:
# Calculando algumas estatísticas para a variável especificada.
utlex.varStats(col = col, data = dataTrain, target = target)
Out[57]:
min Q1 Median Mean Q3 SD Sk Ck
churn
no 0.00 13.980 16.97 16.918909 19.820 4.274863 -0.043103 0.032068
yes 6.03 15.055 17.96 18.054969 21.205 4.396762 0.033144 -0.103840

Destacamos que:

  • A média e a mediana, da carga total à tarde dos grupos, apresenta valores próximos;
  • O coeficiente de assimetria (Sk), evidência que o grupo dos clientes que não efetuaram o churn, tem uma assimetria à esquerda maior;
  • O coeficiente de curtose (Ck), evidência que o grupo dos clientes que efetuaram o churn, apresenta uma calda mais leve que a normal.

4.2.13 Variável total_night_minutes

In [58]:
# Definindo o nome da variável a ser analisada.
col = 'total_night_minutes'

# Definindo o nome da variável Target.
target = 'churn'

# Definindo a descrição da variável nos gráficos.
label = 'Total de minutos à Noite'

# Capturando variáveis especificadas do Dataset.
data = dataTrain[[col, target]]

# Criando uma variável count para contabilizar as ocorrências de cada registro.
data['count'] = 1

# Agrupando dados e contabilizando o número de ocorrências.
data = data.groupby(by = [target, col]).sum()

# Reorganizando DataFrame. 
data = data.reset_index()

# Plotando um gráfico de histograma para a variável especificada.
utlex.plotHist (
    data   = dataTrain[[col, target]],
    title  = 'Histograma para a variável ' + col,
    xaxis  = label,
    yaxis  = 'Frequência Absoluta',
    col    = col,
    target = target,
    groups = True
)
In [59]:
# Criando um gráfico de Densidade para a variável especificada.
utlex.plotDensity (
    data   = dataTrain[[col, target]], 
    title  = 'Gráfico de Densidade para a variável ' + col, 
    xaxis  = label,
    col    = col,
    target = target,
    group  = True
)

O total de minutos à noite para os grupos, tem uma distribuição aproximadamente normal.

In [60]:
# Plotando um gráfico de boxplot para a variável especificada.
utlex.plotBoxplot (
    data   = dataTrain[[col, target]],
    title  = 'Boxplot para a variável ' + col,
    yaxis  = label,
    xaxis  = target.capitalize(),
    col    = col,
    target = target,
    kind   = 'groups'
)

O grupo de clientes que não realizaram o churn, apresenta mais outliers.

In [61]:
# Calculando algumas estatísticas para a variável especificada.
utlex.varStats(col = col, data = dataTrain, target = target)
Out[61]:
min Q1 Median Mean Q3 SD Sk Ck
churn
no 23.2 165.90 200.25 200.133193 234.90 51.105032 0.017230 0.097274
yes 47.4 171.25 204.80 205.231677 239.85 47.132825 -0.005073 -0.089390

Destacamos que:

  • A média e a mediana, do total de minutos à noite dos grupos, apresenta valores próximos;
  • O coeficiente de assimetria (Sk), evidência que os grupos são aproximadamente simétricos e;
  • O coeficiente de curtose (Ck), evidência que os grupos tem um distribuição aproximadamente normal.

4.2.14 Variável total_night_calls

In [62]:
# Definindo o nome da variável a ser analisada.
col = 'total_night_calls'

# Definindo o nome da variável Target.
target = 'churn'

# Definindo a descrição da variável nos gráficos.
label = 'Total de chamadas Noturnas'

# Capturando variáveis especificadas do Dataset.
data = dataTrain[[col, target]]

# Criando uma variável count para contabilizar as ocorrências de cada registro.
data['count'] = 1

# Agrupando dados e contabilizando o número de ocorrências.
data = data.groupby(by = [target, col]).sum()

# Reorganizando DataFrame. 
data = data.reset_index()

# Plotando um gráfico de histograma para a variável especificada.
utlex.plotHist (
    data   = dataTrain[[col, target]],
    title  = 'Histograma para a variável ' + col,
    xaxis  = label,
    yaxis  = 'Frequência Absoluta',
    col    = col,
    target = target,
    groups = True
)

O total de chamadas noturnas para os grupos, aparenta ser normalmente distribuído.

In [63]:
# Criando um gráfico de Densidade para a variável especificada.
utlex.plotDensity (
    data   = dataTrain[[col, target]], 
    title  = 'Gráfico de Densidade para a variável ' + col, 
    xaxis  = label,
    col    = col,
    target = target,
    group  = True
)
In [64]:
# Plotando um gráfico de boxplot para a variável especificada.
utlex.plotBoxplot (
    data   = dataTrain[[col, target]],
    title  = 'Boxplot para a variável ' + col,
    yaxis  = label,
    xaxis  = target.capitalize(),
    col    = col,
    target = target,
    kind   = 'groups'
)

O grupo de clientes que não realizaram o churn, apresenta mais outliers.

In [65]:
# Calculando algumas estatísticas para a variável especificada.
utlex.varStats(col = col, data = dataTrain, target = target)
Out[65]:
min Q1 Median Mean Q3 SD Sk Ck
churn
no 33 87.0 100 100.058246 113.0 19.506246 0.026949 -0.018217
yes 49 85.0 100 100.399586 115.0 19.950659 0.061494 -0.380671

Destacamos que:

  • A média e a mediana, do total de chamadas noturnas dos grupos, apresenta valores próximos;
  • O coeficiente de assimetria (Sk), evidência que os grupos são aproximadamente simétricos;
  • O coeficiente de curtose (Ck), evidência que o grupo dos clientes que efetuaram o churn, apresenta uma calda mais leve que a normal.

4.2.15 Variável total_night_charge

In [66]:
# Definindo o nome da variável a ser analisada.
col = 'total_night_charge'

# Definindo o nome da variável Target.
target = 'churn'

# Definindo a descrição da variável nos gráficos.
label = 'Carga noturna Total'

# Capturando variáveis especificadas do Dataset.
data = dataTrain[[col, target]]

# Criando uma variável count para contabilizar as ocorrências de cada registro.
data['count'] = 1

# Agrupando dados e contabilizando o número de ocorrências.
data = data.groupby(by = [target, col]).sum()

# Reorganizando DataFrame. 
data = data.reset_index()

# Plotando um gráfico de histograma para a variável especificada.
utlex.plotHist (
    data   = dataTrain[[col, target]],
    title  = 'Histograma para a variável ' + col,
    xaxis  = label,
    yaxis  = 'Frequência Absoluta',
    col    = col,
    target = target,
    groups = True
)

A carga noturna total para os grupos, aparenta ser normalmente distribuída.

In [67]:
# Criando um gráfico de Densidade para a variável especificada.
utlex.plotDensity (
    data   = dataTrain[[col, target]], 
    title  = 'Gráfico de Densidade para a variável ' + col, 
    xaxis  = label,
    col    = col,
    target = target,
    group  = True
)
In [68]:
# Plotando um gráfico de boxplot para a variável especificada.
utlex.plotBoxplot (
    data   = dataTrain[[col, target]],
    title  = 'Boxplot para a variável ' + col,
    yaxis  = label,
    xaxis  = target.capitalize(),
    col    = col,
    target = target,
    kind   = 'groups'
)

O grupo de clientes que não realizaram o churn, apresenta mais outliers.

In [69]:
# Calculando algumas estatísticas para a variável especificada.
utlex.varStats(col = col, data = dataTrain, target = target)
Out[69]:
min Q1 Median Mean Q3 SD Sk Ck
churn
no 1.04 7.470 9.01 9.006074 10.570 2.299768 0.017240 0.097067
yes 2.13 7.705 9.22 9.235528 10.795 2.121081 -0.005464 -0.088868

Destacamos que:

  • A média e a mediana, do total de chamadas noturnas dos grupos, apresenta valores próximos;
  • O coeficiente de assimetria (Sk), evidência que os grupos são aproximadamente simétricos e;
  • O coeficiente de curtose (Ck), evidência que os grupos tem um distribuição aproximadamente normal.

4.2.16 Variável total_intl_minutes

In [70]:
# Definindo o nome da variável a ser analisada.
col = 'total_intl_minutes'

# Definindo o nome da variável Target.
target = 'churn'

# Definindo a descrição da variável nos gráficos.
label = 'Total de minutos Internacionais'

# Capturando variáveis especificadas do Dataset.
data = dataTrain[[col, target]]

# Criando uma variável count para contabilizar as ocorrências de cada registro.
data['count'] = 1

# Agrupando dados e contabilizando o número de ocorrências.
data = data.groupby(by = [target, col]).sum()

# Reorganizando DataFrame. 
data = data.reset_index()

# Plotando um gráfico de histograma para a variável especificada.
utlex.plotHist (
    data   = dataTrain[[col, target]],
    title  = 'Histograma para a variável ' + col,
    xaxis  = label,
    yaxis  = 'Frequência Absoluta',
    col    = col,
    target = target,
    groups = True
)
In [71]:
# Criando um gráfico de Densidade para a variável especificada.
utlex.plotDensity (
    data   = dataTrain[[col, target]], 
    title  = 'Gráfico de Densidade para a variável ' + col, 
    xaxis  = label,
    col    = col,
    target = target,
    group  = True
)
In [72]:
# Plotando um gráfico de boxplot para a variável especificada.
utlex.plotBoxplot (
    data   = dataTrain[[col, target]],
    title  = 'Boxplot para a variável ' + col,
    yaxis  = label,
    xaxis  = target.capitalize(),
    col    = col,
    target = target,
    kind   = 'groups'
)

O grupo de clientes que não realizaram o churn, apresenta mais outliers.

In [73]:
# Calculando algumas estatísticas para a variável especificada.
utlex.varStats(col = col, data = dataTrain, target = target)
Out[73]:
min Q1 Median Mean Q3 SD Sk Ck
churn
no 0.0 8.4 10.2 10.158877 12.0 2.784489 -0.293780 0.683283
yes 2.0 8.8 10.6 10.700000 12.8 2.793190 0.021392 -0.012325

Destacamos que:

  • A média e a mediana, do total de minutos internacionais dos grupos, apresenta valores próximos;
  • O coeficiente de assimetria (Sk), evidência que o grupo dos clientes que não efetuaram o churn, tem uma assimetria à esquerda maior;
  • O coeficiente de curtose (Ck), evidência que o grupo dos clientes que não efetuaram o churn, apresenta uma calda mais pesada que a normal.

4.2.17 Variável total_intl_calls

In [74]:
# Definindo o nome da variável a ser analisada.
col = 'total_intl_calls'

# Definindo o nome da variável Target.
target = 'churn'

# Definindo a descrição da variável nos gráficos.
label = 'Total de chamadas Internacionais'

# Capturando variáveis especificadas do Dataset.
data = dataTrain[[col, target]]

# Criando uma variável count para contabilizar as ocorrências de cada registro.
data['count'] = 1

# Agrupando dados e contabilizando o número de ocorrências.
data = data.groupby(by = [target, col]).sum()

# Reorganizando DataFrame. 
data = data.reset_index()

# Plotando um gráfico de barras para a variável especificada.
utlex.plotBar (
    data        = data,
    col         = col,
    target      = target,
    title       = 'Churn dos clientes por ' + label,
    yaxis       = 'Frequência Absoluta',
    xaxis       = label, 
    kind        = 'groups',
    orientation = 'h'
)

Os grupos de cliente, possuem uma assimetria à direita.

In [75]:
# Criando um gráfico de Densidade para a variável especificada.
utlex.plotDensity (
    data   = dataTrain[[col, target]], 
    title  = 'Gráfico de Densidade para a variável ' + col, 
    xaxis  = label,
    col    = col,
    target = target,
    group  = True
)
In [76]:
# Plotando um gráfico de boxplot para a variável especificada.
utlex.plotBoxplot (
    data   = dataTrain[[col, target]],
    title  = 'Boxplot para a variável ' + col,
    yaxis  = label,
    xaxis  = target.capitalize(),
    col    = col,
    target = target,
    kind   = 'groups'
)

O grupo de clientes que não realizaram o churn, apresenta mais outliers.

In [77]:
# Calculando algumas estatísticas para a variável especificada.
utlex.varStats(col = col, data = dataTrain, target = target)
Out[77]:
min Q1 Median Mean Q3 SD Sk Ck
churn
no 0 3.0 4 4.532982 6.0 2.441984 1.259044 2.798436
yes 1 2.0 4 4.163561 5.0 2.551575 1.714231 4.821751

Destacamos que:

  • A média e a mediana, do total de chamadas internacionais dos grupos, apresenta valores próximos;
  • O coeficiente de assimetria (Sk), evidência que os grupos dos clientes que realizaram o churn, tem uma assimetria à direita maior e;
  • O coeficiente de curtose (Ck), evidência que os grupos dos clientes que realizaram o churn, apresentam uma calda mais pesada que a normal.

4.2.18 Variável total_intl_charge

In [78]:
# Definindo o nome da variável a ser analisada.
col = 'total_intl_charge'

# Definindo o nome da variável Target.
target = 'churn'

# Definindo a descrição da variável nos gráficos.
label = 'Carga Internacional Total'

# Capturando variáveis especificadas do Dataset.
data = dataTrain[[col, target]]

# Criando uma variável count para contabilizar as ocorrências de cada registro.
data['count'] = 1

# Agrupando dados e contabilizando o número de ocorrências.
data = data.groupby(by = [target, col]).sum()

# Reorganizando DataFrame. 
data = data.reset_index()

# Plotando um gráfico de histograma para a variável especificada.
utlex.plotHist (
    data   = dataTrain[[col, target]],
    title  = 'Histograma para a variável ' + col,
    xaxis  = label,
    yaxis  = 'Frequência Absoluta',
    col    = col,
    target = target,
    groups = True
)
In [79]:
# Criando um gráfico de Densidade para a variável especificada.
utlex.plotDensity (
    data   = dataTrain[[col, target]], 
    title  = 'Gráfico de Densidade para a variável ' + col, 
    xaxis  = label,
    col    = col,
    target = target,
    group  = True
)

A carga internacional total para os grupos, tem uma distribuição aproximadamente normal.

In [80]:
# Plotando um gráfico de boxplot para a variável especificada.
utlex.plotBoxplot (
    data   = dataTrain[[col, target]],
    title  = 'Boxplot para a variável ' + col,
    yaxis  = label,
    xaxis  = target.capitalize(),
    col    = col,
    target = target,
    kind   = 'groups'
)

O grupo de clientes que não realizaram o churn, apresenta mais outliers.

In [81]:
# Calculando algumas estatísticas para a variável especificada.
utlex.varStats(col = col, data = dataTrain, target = target)
Out[81]:
min Q1 Median Mean Q3 SD Sk Ck
churn
no 0.00 2.27 2.75 2.743404 3.24 0.751784 -0.293902 0.683996
yes 0.54 2.38 2.86 2.889545 3.46 0.754152 0.021009 -0.013370

Destacamos que:

  • A média e a mediana, da carga internacional total dos grupos, apresenta valores próximos;
  • O coeficiente de assimetria (Sk), evidência que o grupo dos clientes que não efetuaram o churn, tem uma assimetria à esquerda maior;
  • O coeficiente de curtose (Ck), evidência que o grupo dos clientes que não efetuaram o churn, apresenta uma calda mais pesada que a normal.

4.2.19 Variável number_customer_service_calls

In [82]:
# Definindo o nome da variável a ser analisada.
col = 'number_customer_service_calls'

# Definindo o nome da variável Target.
target = 'churn'

# Definindo a descrição da variável nos gráficos.
label = 'Número de chamadas de atendimento ao Cliente'

# Capturando variáveis especificadas do Dataset.
data = dataTrain[[col, target]]

# Criando uma variável count para contabilizar as ocorrências de cada registro.
data['count'] = 1

# Agrupando dados e contabilizando o número de ocorrências.
data = data.groupby(by = [target, col]).sum()

# Reorganizando DataFrame. 
data = data.reset_index()

# Plotando um gráfico de barras para a variável especificada.
utlex.plotBar (
    data        = data,
    col         = col,
    target      = target,
    title       = 'Churn dos clientes por ' + label,
    yaxis       = 'Frequência Absoluta',
    xaxis       = label, 
    kind        = 'groups',
    orientation = 'h'
)

Os grupos possuem uma assimetria à direita.

In [83]:
# Criando um gráfico de Densidade para a variável especificada.
utlex.plotDensity (
    data   = dataTrain[[col, target]], 
    title  = 'Gráfico de Densidade para a variável ' + col, 
    xaxis  = label,
    col    = col,
    target = target,
    group  = True
)

O grupo dos clientes que não realizaram o churn, apresentam 4 modas para o número de chamadas de atendimento ao cliente: 1, 2, 3 e 4.

In [84]:
# Plotando um gráfico de boxplot para a variável especificada.
utlex.plotBoxplot (
    data   = dataTrain[[col, target]],
    title  = 'Boxplot para a variável ' + col,
    yaxis  = label,
    xaxis  = target.capitalize(),
    col    = col,
    target = target,
    kind   = 'groups'
)

O grupo de clientes que não realizaram o churn, apresenta mais outliers.

In [85]:
# Calculando algumas estatísticas para a variável especificada.
utlex.varStats(col = col, data = dataTrain, target = target)
Out[85]:
min Q1 Median Mean Q3 SD Sk Ck
churn
no 0 1.0 1 1.449825 2.0 1.163883 0.886801 1.210349
yes 0 1.0 2 2.229814 4.0 1.853275 0.703604 -0.109937

Destacamos que:

  • A média e a mediana, do número de chamadas de atendimento ao cliente dos grupos, apresenta valores diferentes;
  • O coeficiente de assimetria (Sk), evidência que o grupo dos clientes que não efetuaram o churn, tem uma assimetria à direita maior;
  • O coeficiente de curtose (Ck), evidência que o grupo dos clientes que não efetuaram o churn, apresenta uma calda mais pesada que a normal.

4.3 Analisando a correlação entre as variáveis

Nesta etapa, desejamos verificar como as variáveis se correlacionam, ou seja, como uma variável ajuda a prever o valor de outra variável no dataset.

In [86]:
# Criando uma matriz de correlação.
corr = dataTrain.corr()

# Selecionando o triângulo superior da matriz de correlação.
upper = corr.abs().where(np.triu(np.ones(corr.shape), k = 1).astype(bool))

# Capturando o nome das variáveis que apresentam uma correlação maior do que 0.95.
to_drop = [column for column in upper.columns if any(upper[column] > 0.95)]

# Exibindo o nome das variáveis altamente correlacionadas.
pd.DataFrame(data = to_drop, columns = ['Highly correlated'])
Out[86]:
Highly correlated
0 total_day_charge
1 total_eve_charge
2 total_night_charge
3 total_intl_charge
4 voice_mail_plan_dummy
In [87]:
# Plotando a matriz de correlação entre as variáveis do DataFrame.
utlex.plotCorr(corr)

Detectamos a existência de variáveis altamente correlacionadas, dentre elas, 5 estão perfeitamente correlacionadas e deverão ser eliminadas dos conjuntos de dados.

Observamos que as variáveis total_day_minutes, total_day_charge, number_customer_service_calls e international_plan_dummy são as que apresentam as correlações mais fortes com a variável a ser prevista.

5. Feature Selection

5.1 Extraindo Features dos conjuntos de dados

Iremos separar as variáveis preditoras, da variável a ser prevista, dentro do conjunto de dados.

In [88]:
# Eliminando as variáveis altamente correlacionadas dos conjuntos de dados de treino e de teste.
dataTrain = dataTrain.drop(to_drop, axis = 1)
dataTest  = dataTest.drop(to_drop, axis = 1)
In [89]:
# Capturando o nome das colunas do tipo categórico presentes no DataFrame.
categ = dataTrain.select_dtypes(['category']).columns

# Capturando as variáveis targets do conjunto de dados de treino e de teste.
trainTarget = dataTrain['churn_dummy']
testTarget  = dataTest['churn_dummy']

# Eliminando as variáveis target do conjunto de dados de treino e de teste.
trainFeatures = dataTrain.drop(labels = 'churn_dummy', axis = 1)
testFeatures  = dataTest.drop(labels = 'churn_dummy', axis = 1)

# Eliminando as variáveis categóricas do conjunto de dados de treino e de teste.
trainFeatures = trainFeatures.drop(labels = categ, axis = 1)
testFeatures  = testFeatures.drop(labels = categ, axis = 1)
In [90]:
# Verificando as novas dimensões do DataFrame de treino.
trainFeatures.shape
Out[90]:
(3333, 13)
In [91]:
# Verificando as novas dimensões do DataFrame de teste.
testFeatures.shape
Out[91]:
(1667, 13)

5.2 Balanceando variável target

In [92]:
# Seed para reproduzir o mesmo resultado
seed = 100

# Cria o balanceador SMOTE
smote_bal = SMOTE(random_state = seed)

# Aplica o balanceador
trainFeatures_res, trainTarget_res = smote_bal.fit_resample(trainFeatures, trainTarget)
In [93]:
# Shape dos dados originais
trainFeatures.shape
Out[93]:
(3333, 13)
In [94]:
# Shape dos dados reamostrados 
trainFeatures_res.shape
Out[94]:
(5700, 13)
In [95]:
# Shape dos dados reamostrados 
trainTarget_res.shape
Out[95]:
(5700,)
In [96]:
# Convertendo Serie dados reamostrados variavel target para dataframe.
df = trainTarget_res.to_frame()

# Atribuindo labels diferentes para as categorias da variável target.
df['churn_dummy'] = ['Yes' if v == 1 else 'No' for v in df['churn_dummy']]

# Alterando a variável target para o tipo de dado categórico.

df['churn_dummy'] = df['churn_dummy'].astype('category')
In [97]:
# Definindo o nome da variável a ser analisada.
col = 'churn_dummy'

# Definindo a descrição da variável nos gráficos.
label = 'Churn'

# Contabilizando a frequência absoluta, de cada categoria presente na variável especificada.
dataCounts = df[col].value_counts()

# Plotando um gráfico de barras para a variável especificada.
utlex.plotBar (
    data = dataCounts,
    title = 'Frequência absoluta das categorias da Feature ' + col + ' após balanceamento de classe', 
    yaxis = 'Frequência Absoluta', 
    xaxis = label
)
In [98]:
# Plotando um gráfico de pizza para a variável especificada.
utlex.plotPie (
    data  = dataCounts, 
    title = 'Frequência relativa das categorias da feature ' + col + ' após balanceamento de classe'
)

Agora que nossa variável target esta balanceada podemos seguir com a divisão dos dados em treino e teste e a seleção das melhores variáveis para a modelagem preditiva.

5.3 Aplicando diferentes escalas as Features de Treino

In [99]:
# Criando um objeto da classe MinMaxScaler().
scaler = MinMaxScaler()

# Aplicando a escala nas Features e capturando o resultado obtido.
trainFeaturesMM = scaler.fit_transform(trainFeatures)

# Criando um DataFrame com os resultados obtidos.
trainFeaturesMM = pd.DataFrame(data = trainFeaturesMM, columns = trainFeatures.columns)
In [100]:
# Criando um objeto da classe StandardScaler().
scaler = StandardScaler()

# Aplicando a escala nas Features e capturando o resultado obtido.
trainFeaturesStandScaler = scaler.fit_transform(trainFeatures)

# Criando um DataFrame com os resultados obtidos.
trainFeaturesStandScaler = pd.DataFrame(data = trainFeaturesStandScaler, columns = trainFeatures.columns)
In [101]:
# Criando um objeto da classe StandardScaler().
scaler = PowerTransformer(method = 'yeo-johnson', standardize = False)

# Aplicando a escala nas Features e capturando o resultado obtido.
trainFeaturesNormDistribuition = scaler.fit_transform(trainFeaturesStandScaler)

# Criando um DataFrame com os resultados obtidos.
trainFeaturesNormDistribuition = pd.DataFrame(data = trainFeaturesNormDistribuition, columns = trainFeatures.columns)
In [102]:
# Normalizando cada feature para uma unidade uniforme (vetor unitário).
trainFeaturesNormalized = normalize(trainFeatures, axis = 1)

# Criando um DataFrame com os resultados obtidos.
trainFeaturesNormalized = pd.DataFrame(data = trainFeaturesNormalized, columns = trainFeatures.columns)

5.4 Aplicando técnicas de Features Selection

Aplicaremos diferentes técnicas de Feature Selection, para determinar qual é a melhor combinação de variáveis preditoras a ser utilizada.

5.4.1 SelectKBest

Este método seleciona recursos de acordo com as k pontuações mais altas.

In [103]:
# Definindo qual conjunto de dados, já escalado, deve ser utilizado.
tFeatures = trainFeaturesMM

# Instanciando um objeto da classe SelectKBest, para selecionar as melhores variáveis preditoras.
skb = SelectKBest(chi2, k = 9)

# Capturando os scores das variáveis preditoras.
bestFeatuesSKB = skb.fit_transform(tFeatures, trainTarget)

# Capturando o nome das variáveis preditoras.
bfSkb = tFeatures.columns[skb.get_support()]

# Exibindo o nome das variáveis preditoras.
bfSkb
Out[103]:
Index(['account_length', 'number_vmail_messages', 'total_day_minutes',
       'total_eve_minutes', 'total_night_minutes', 'total_intl_minutes',
       'total_intl_calls', 'number_customer_service_calls',
       'international_plan_dummy'],
      dtype='object')
In [104]:
# Criando um DataFrame com os scores obtidos para cada uma das Features segundo a técnica utilizada.
sc = pd.DataFrame(skb.scores_, index = tFeatures.columns, columns = ['score'])

# Capturando os scores das melhores variáveis preditoras.
sc = sc[skb.get_support()]

# Ordenando o Dataframe com os scores.
sc = sc.sort_values(by = 'score', ascending = False)
In [105]:
# Plotando um gráfico de barras, dos scores gerados para as features, a partir da técnica utilizada.
utlex.plotBar (
    data        = sc.score,
    title       = 'Scores das melhores features com o SelectKBest', 
    yaxis       = 'Features', 
    xaxis       = 'Scores',
    orientation = 'h'
)

5.4.2 Information Gain

O Information gain ou Mutual information mede quanta informação a presença / ausência de um recurso contribui para fazer a previsão correta da variável target.

In [106]:
# Definindo qual conjunto de dados, já escalado, deve ser utilizado.
tFeatures = trainFeaturesMM

# Instanciando um objeto da classe mutual_info_classif.
bestFeatuesIG = mutual_info_classif(tFeatures, trainTarget, discrete_features = 'auto', n_neighbors = 3)

# Inserindo Scores obtidos em um DataFrame.
scoreFeatures = pd.DataFrame(bestFeatuesIG, index = tFeatures.columns,  columns = ['score'])

# Capturando as 5 variáveis com os maiores scores.
bfIg = scoreFeatures.sort_values(by='score', ascending=False).head(9)
In [107]:
# Plotando um gráfico de barras, dos scores gerados para as features, a partir da técnica utilizada.
utlex.plotBar (
    data        = bfIg.score,
    title       = 'Scores das melhores features com o Information Gain', 
    yaxis       = 'Features', 
    xaxis       = 'Scores', 
    orientation = 'h'
)
In [108]:
# Capturando o nome das variáveis preditoras.
bfIg = bfIg.index

# Exibindo o nome das variáveis preditoras.
bfIg
Out[108]:
Index(['total_day_minutes', 'number_customer_service_calls',
       'international_plan_dummy', 'number_vmail_messages', 'state_dummy',
       'total_day_calls', 'total_intl_calls', 'account_length',
       'total_eve_minutes'],
      dtype='object')

5.4.3 ANOVA F-value

Se os recursos forem categóricos, calcularemos uma estatística qui-quadrado entre cada recurso e a variável target. No entanto, se os recursos forem quantitativos, calcularemos a ANOVA F-Value entre cada recurso e a variável target.

As pontuações do F-Value examinam se, quando agrupamos a característica numérica pela variável target, as médias para cada grupo se tornam significativamente diferentes.

In [109]:
# Definindo qual conjunto de dados, já escalado, deve ser utilizado.
tFeatures = trainFeaturesMM

# Instanciando um objeto da classe SelectKBest para selecionar as 5 melhores variáveis preditoras a partir 
# do scores ANOVA F-Values.
skb = SelectKBest(f_classif, k = 9)

# Capturando as melhores variáveis preditoras.
bestFeatuesANOVA = skb.fit_transform(tFeatures, trainTarget)

# Capturando o nome das melhores variáveis preditoras.
bfAnova = tFeatures.columns[skb.get_support()]

# Exibindo o nome das melhores variáveis preditoras.
bfAnova
Out[109]:
Index(['number_vmail_messages', 'total_day_minutes', 'total_day_calls',
       'total_eve_minutes', 'total_night_minutes', 'total_intl_minutes',
       'total_intl_calls', 'number_customer_service_calls',
       'international_plan_dummy'],
      dtype='object')
In [110]:
# Criando um DataFrame com os scores obtidos para cada uma das Features segundo a técnica utilizada.
sc = pd.DataFrame(skb.scores_, index = tFeatures.columns, columns = ['score'])

# Capturando os scores das melhores variáveis preditoras.
sc = sc[skb.get_support()]

# Ordenando o Dataframe com os scores.
sc = sc.sort_values(by = 'score', ascending = False)
In [111]:
# Plotando um gráfico de barras, dos scores gerados para as features, a partir da técnica utilizada.
utlex.plotBar (
    data        = sc.score,
    title       = 'Scores das melhores features com o ANOVA F-value', 
    yaxis       = 'Features', 
    xaxis       = 'Scores', 
    orientation = 'h'
)

5.4.4 Forward Selection

O Forward Selection é um método iterativo, no qual começamos sem ter nenhum recurso no modelo. A cada iteração, adicionamos uma variável que melhora o modelo e efetuamos este procedimento até que a performance do modelo pare de evoluir.

A seleção de recursos começa avaliando todas as variáveis individualmente, e seleciona aquela que gera o algoritmo com o melhor desempenho, de acordo com um critério de avaliação predefinido. Em seguida, se avalia todas as combinações possíveis das variáveis já selecionadas e dos recursos ainda não escolhidos para definir a combinação que produz o algoritmo com a melhor performance, com base nos mesmos critérios predefinidos.

In [112]:
# Definindo qual conjunto de dados, já escalado, deve ser utilizado.
tFeatures = trainFeaturesMM

# Instanciando um objeto da classe SFS para selecionar as melhores variáveis preditoras segundo sua acurácia, 
# utilizando o algoritmo XGBClassifer.
sfs = SFS (
    estimator  = xgb.XGBClassifier(use_label_encoder=False,eval_metric='mlogloss'), 
    k_features = 9,
    forward    = True, 
    floating   = False, 
    verbose    = 2,
    scoring    = 'accuracy',
    cv         = 3
)

# Capturando as variáveis preditoras.
sfs = sfs.fit(
    X = tFeatures, 
    y = trainTarget
)
[Parallel(n_jobs=1)]: Using backend SequentialBackend with 1 concurrent workers.
[Parallel(n_jobs=1)]: Done   1 out of   1 | elapsed:    0.6s remaining:    0.0s
[Parallel(n_jobs=1)]: Done  13 out of  13 | elapsed:    3.7s finished

[2021-12-23 10:17:39] Features: 1/9 -- score: 0.8619861986198619[Parallel(n_jobs=1)]: Using backend SequentialBackend with 1 concurrent workers.
[Parallel(n_jobs=1)]: Done   1 out of   1 | elapsed:    0.2s remaining:    0.0s
[Parallel(n_jobs=1)]: Done  12 out of  12 | elapsed:    3.6s finished

[2021-12-23 10:17:42] Features: 2/9 -- score: 0.8730873087308731[Parallel(n_jobs=1)]: Using backend SequentialBackend with 1 concurrent workers.
[Parallel(n_jobs=1)]: Done   1 out of   1 | elapsed:    0.4s remaining:    0.0s
[Parallel(n_jobs=1)]: Done  11 out of  11 | elapsed:    5.2s finished

[2021-12-23 10:17:48] Features: 3/9 -- score: 0.8997899789978998[Parallel(n_jobs=1)]: Using backend SequentialBackend with 1 concurrent workers.
[Parallel(n_jobs=1)]: Done   1 out of   1 | elapsed:    0.4s remaining:    0.0s
[Parallel(n_jobs=1)]: Done  10 out of  10 | elapsed:    5.8s finished

[2021-12-23 10:17:54] Features: 4/9 -- score: 0.9165916591659166[Parallel(n_jobs=1)]: Using backend SequentialBackend with 1 concurrent workers.
[Parallel(n_jobs=1)]: Done   1 out of   1 | elapsed:    0.7s remaining:    0.0s
[Parallel(n_jobs=1)]: Done   9 out of   9 | elapsed:    5.1s finished

[2021-12-23 10:17:59] Features: 5/9 -- score: 0.9237923792379238[Parallel(n_jobs=1)]: Using backend SequentialBackend with 1 concurrent workers.
[Parallel(n_jobs=1)]: Done   1 out of   1 | elapsed:    0.5s remaining:    0.0s
[Parallel(n_jobs=1)]: Done   8 out of   8 | elapsed:    4.5s finished

[2021-12-23 10:18:03] Features: 6/9 -- score: 0.924992499249925[Parallel(n_jobs=1)]: Using backend SequentialBackend with 1 concurrent workers.
[Parallel(n_jobs=1)]: Done   1 out of   1 | elapsed:    0.5s remaining:    0.0s
[Parallel(n_jobs=1)]: Done   7 out of   7 | elapsed:    4.0s finished

[2021-12-23 10:18:08] Features: 7/9 -- score: 0.9246924692469247[Parallel(n_jobs=1)]: Using backend SequentialBackend with 1 concurrent workers.
[Parallel(n_jobs=1)]: Done   1 out of   1 | elapsed:    0.5s remaining:    0.0s
[Parallel(n_jobs=1)]: Done   6 out of   6 | elapsed:    3.6s finished

[2021-12-23 10:18:11] Features: 8/9 -- score: 0.9333933393339334[Parallel(n_jobs=1)]: Using backend SequentialBackend with 1 concurrent workers.
[Parallel(n_jobs=1)]: Done   1 out of   1 | elapsed:    0.4s remaining:    0.0s
[Parallel(n_jobs=1)]: Done   5 out of   5 | elapsed:    2.6s finished

[2021-12-23 10:18:14] Features: 9/9 -- score: 0.9543954395439544
In [113]:
# Capturando o nome das variáveis preditoras.
bfSfs = tFeatures.columns[list(sfs.k_feature_idx_)]

# Exibindo o nome das variáveis preditoras.
bfSfs
Out[113]:
Index(['number_vmail_messages', 'total_day_minutes', 'total_eve_minutes',
       'total_eve_calls', 'total_night_minutes', 'total_intl_minutes',
       'total_intl_calls', 'number_customer_service_calls',
       'international_plan_dummy'],
      dtype='object')
In [114]:
# Capturando os resultados obtidos pela Técnica Forward Selection.
sc = pd.DataFrame(sfs.get_metric_dict())

# Capturando os scores e o nome das Features, gerados a cada busca.
sc = sc.loc[['cv_scores', 'feature_names'], :].transpose()

# Capturando o nome das features utilizadas em cada avaliação.
featureNames = sc.feature_names

# Criando índices com o número de Features utilizadas em cada avaliação.
columns = [str(i) + ' Feature' if i == 1 else str(i) + ' Features' for i in range(1, sc.shape[0] + 1)]

# Remodelando os dados do DataFrame para serem plotados.
fs = pd.DataFrame()

for i in range(1, sc.shape[0] + 1):

    # Atribui os primeiros scores ao DataFrame, caso esteja vazio.

    if sc.empty:
        fs = pd.DataFrame(sc['cv_scores'][i], columns = [columns[i - 1]])
    else:
        fs[columns[i - 1]] = sc['cv_scores'][i]
In [115]:
# Plotando os scores da acurácia, obtida pelas features selecionadas em cada fase de busca, segundo a técnica Forward Selection.
utlex.plotBoxplot (
    data   = fs,
    title  = 'Acurácia das melhores Features encontradas pelo técnica Forward Selection',
    xaxis  = 'Features selecionadas'
)
In [116]:
# Transpondo a Série Temporal.
fs = fs.transpose()

# Criando uma nova coluna, com os nomes das Features utilizadas, em cada avaliação no DataFrame.
fs['featuresNames'] = [', '.join(f) for f in featureNames]

# Exibindo o nome das features utilizadas em cada avaliação.
fs[['featuresNames']]
Out[116]:
featuresNames
1 Feature number_customer_service_calls
2 Features total_day_minutes, number_customer_service_calls
3 Features total_day_minutes, total_eve_minutes, number_c...
4 Features number_vmail_messages, total_day_minutes, tota...
5 Features number_vmail_messages, total_day_minutes, tota...
6 Features number_vmail_messages, total_day_minutes, tota...
7 Features number_vmail_messages, total_day_minutes, tota...
8 Features number_vmail_messages, total_day_minutes, tota...
9 Features number_vmail_messages, total_day_minutes, tota...

5.4.5 Extra Trees Classifier

O Extremely Randomized Trees Classifier (Extra Trees Classifier) é um tipo de técnica de aprendizagem de conjunto que agrega os resultados de várias árvores de decisão descorrelacionadas coletadas em uma “floresta” para produzir seu resultado de classificação. Em conceito, é muito semelhante a um Classificador Random Forest e só difere na forma de construção das árvores de decisão na floresta.

Cada árvore de decisão na floresta de árvores extras é construída a partir da amostra de treinamento original. Então, em cada nó de teste, cada árvore é fornecida com uma amostra aleatória de k recursos do conjunto de recursos a partir do qual cada árvore de decisão deve selecionar o melhor recurso para dividir os dados com base em alguns critérios matemáticos (normalmente o índice de Gini). Essa amostra aleatória de recursos leva à criação de várias árvores de decisão não correlacionadas.

Para realizar a seleção de características usando a estrutura de floresta acima, durante a construção da floresta, para cada característica, a redução total normalizada nos critérios matemáticos usados ​​na decisão da característica de divisão (Índice de Gini se o Índice de Gini for usado na construção de floresta) é computado. Esse valor é chamado de Importância Gini do recurso. Para realizar a seleção de recursos, cada recurso é ordenado em ordem decrescente de acordo com a Importância Gini de cada recurso e o usuário seleciona os k principais recursos de acordo com sua escolha.

In [117]:
# Definindo qual conjunto de dados, já escalado, deve ser utilizado.
tFeatures = trainFeaturesMM

# Instanciando um objeto da classe ExtraTreesClassifier.
modelETC = ExtraTreesClassifier()

# Computando os scores de cada feature.
modelETC.fit (
    X = tFeatures, 
    y = trainTarget
)

# Inserindo Scores obtidos em uma Série Temporal.
featuresImpETC = pd.DataFrame(data = modelETC.feature_importances_, index = tFeatures.columns, columns = ['score'])

# Ordenando o nome das variáveis preditoras segundo seu score em ordem decrescente.
bfEtc = featuresImpETC.sort_values(by = 'score', ascending = False).head(9)
In [118]:
# Plotando um gráfico de barras, dos scores gerados para as features, a partir da técnica utilizada.
utlex.plotBar (
    data        = bfEtc.score, 
    title       = 'Scores das melhores features com o Extra Trees Classifier', 
    yaxis       = 'Features', 
    xaxis       = 'Scores', 
    orientation = 'h'
)
In [119]:
# Capturando o nome das variáveis preditoras.
bfEtc = bfEtc.index

# Exibindo o nome das variáveis preditoras.
bfEtc
Out[119]:
Index(['total_day_minutes', 'number_customer_service_calls',
       'total_eve_minutes', 'total_intl_calls', 'international_plan_dummy',
       'total_intl_minutes', 'total_night_minutes', 'total_day_calls',
       'account_length'],
      dtype='object')

5.4.6 Random Forest Importance

O Random Forest, é um dos algoritmos de aprendizado de máquina mais populares. É um dos mais bem-sucedidos porque fornece, em geral, um bom desempenho preditivo, baixo overfitting e é de fácil interpretabilidade.

Essa interpretabilidade é dada pela facilidade de se derivar a importância de cada variável na árvore de decisão. Em outras palavras, é fácil calcular o quanto cada variável está contribuindo para a decisão do modelo.

O Random Forest consiste em 4-12 centenas de árvores de decisão, cada uma delas construída sobre uma extração aleatória das observações do conjunto de dados e uma extração aleatória das características. Nem toda árvore vê todas as características ou todas as observações, e isso garante que as árvores sejam descorrelacionadas e, portanto, menos sujeitas a sobreajuste. Cada árvore também é uma sequência de perguntas sim-não com base em um único recurso ou em uma combinação de recursos. Em cada nó (isto é em cada questão), os três dividem o conjunto de dados em 2 depósitos, cada um deles hospedando observações que são mais semelhantes entre si e diferentes das do outro bloco. Portanto, a importância de cada recurso é derivada do quão "puro" cada um dos blocos é.

Para classificação, a medida de impureza é a impureza de Gini ou o ganho / entropia de informação. Para regressão, a medida de impureza é a variância. Portanto, ao treinar uma árvore, é possível calcular o quanto cada recurso diminui a impureza. Quanto maior for a diminuição da impureza que um recurso gerar, mais importante ele será. Em florestas aleatórias, a diminuição da impureza de cada recurso pode ser calculada em média entre as árvores para determinar a importância final da variável.

In [120]:
# Definindo qual conjunto de dados, já escalado, deve ser utilizado.
tFeatures = trainFeaturesMM

# Instanciando um objeto da classe RandomForestClassifier.
rfImp = RandomForestClassifier (
    n_estimators = 200,
    random_state = 0
)

# Treinando o classificador com o conjunto de dados de treino.
rfImp.fit(
    X = tFeatures, 
    y = trainTarget
)

# Prevendo os scores das features dos dados de treino.
pred = rfImp.predict(tFeatures)

# Convertendo os scores para um DataFrame.
featuresImpRf = pd.Series(data = rfImp.feature_importances_, index = tFeatures.columns)

# Capturando os scores de cada uma das features.
bfRf = featuresImpRf.nlargest(9)
In [121]:
# Plotando um gráfico de barras, dos scores gerados para as features, a partir da técnica utilizada.
utlex.plotBar (
    data        = bfRf,
    title       = 'Scores das melhores features com o Random Forest', 
    yaxis       = 'Features', 
    xaxis       = 'Scores', 
    orientation = 'h'
)
In [122]:
# Capturando o nome das variáveis preditoras.
bfRf = bfRf.index

# Exibindo o nome das variáveis preditoras.
bfRf
Out[122]:
Index(['total_day_minutes', 'number_customer_service_calls',
       'total_eve_minutes', 'international_plan_dummy', 'total_intl_minutes',
       'total_intl_calls', 'total_night_minutes', 'account_length',
       'total_day_calls'],
      dtype='object')

5.4.7 PCA

A Análise de componente principal (Principal Component Analysis - PCA) é uma técnica de redução de dimensionalidade linear que pode ser utilizada para extrair informações de um espaço de alta dimensão projetando-as em um subespaço de dimensão inferior. Ele tenta preservar as partes essenciais que têm mais variação dos dados e remover as partes não essenciais com menos variação. As dimensões nada mais são do que recursos que representam os dados.

Uma coisa importante a se notar sobre o PCA é que é uma técnica de redução de dimensionalidade não supervisionada. Você pode agrupar os pontos de dados semelhantes com base na correlação de recursos entre eles sem qualquer supervisão (ou rótulos).

In [123]:
# Aplicando a técnica PCA, para criar 10 Componentes, a partir dos dados de treino e de teste.
trainFeaturesPCA, testFeaturesPCA =  utlpca.pcaTransform(train = trainFeatures, test = testFeatures)

5.4.8 RFE

RFE é um algoritmo de seleção de recurso do tipo wrapper. Isso significa que um algoritmo de aprendizado de máquina diferente é fornecido e usado no núcleo do método, é empacotado pelo RFE e usado para ajudar a selecionar recursos. Isso contrasta com as seleções de recursos com base em filtro que pontuam cada recurso e selecionam os recursos com a maior (ou menor) pontuação.

Tecnicamente, o RFE é um algoritmo de seleção de recursos no estilo wrapper que também usa a seleção de recursos com base em filtro internamente.

O RFE funciona procurando por um subconjunto de recursos começando com todos os recursos no conjunto de dados de treinamento e removendo com sucesso os recursos até que o número desejado permaneça.

Isso é obtido ajustando-se o algoritmo de aprendizado de máquina usado no núcleo do modelo, classificando os recursos por importância, descartando os recursos menos importantes e reajustando o modelo. Este processo é repetido até que um determinado número de recursos permaneça.

Os recursos são pontuados usando o modelo de aprendizado de máquina fornecido ou usando um método estatístico.

In [124]:
# Definindo qual conjunto de dados, já escalado, deve ser utilizado.
tFeatures = trainFeaturesMM

# Instanciando um objeto da classe RFE para selecionar as melhores variáveis preditoras, utilizando o algoritmo XGBClassifer.
rfe = RFE (
    estimator            = xgb.XGBClassifier(use_label_encoder=False,eval_metric='mlogloss'), 
    n_features_to_select = 9
)

# Capturando as melhores variáveis preditoras.
rfeFit = rfe.fit (
    X = tFeatures, 
    y = trainTarget
)
In [125]:
# Capturando o nome das variáveis preditoras.
bfRfe = tFeatures.columns[rfeFit.support_]

# Exibindo o nome das variáveis preditoras.
bfRfe
Out[125]:
Index(['number_vmail_messages', 'total_day_minutes', 'total_day_calls',
       'total_eve_minutes', 'total_night_minutes', 'total_intl_minutes',
       'total_intl_calls', 'number_customer_service_calls',
       'international_plan_dummy'],
      dtype='object')

5.5 Avaliando resultados

In [126]:
# Criando uma lista, com todos os resultados gerados pelas técnicas de Feature Selection utilizadas.
bestFeaturesNames = [bfSkb.values, bfIg.values, bfAnova.values, bfSfs.values, bfEtc.values, bfRf.values, bfRfe.values]

# Convertendo a lista, para um DataFrame, com as features organizadas em ordem alfabética.
bestFeaturesNamesOrdered = pd.DataFrame (
    data    = [sorted(r) for r in bestFeaturesNames], 
    index   = ['skb', 'ig', 'anova', 'sfs', 'etc', 'rf', 'rfe'],  
    columns = ['Feature' + str(i) for i in range(1, bestFeaturesNames[1].shape[0] +  1)]
)

# Convertendo a lista para um DataFrame.
bestFeaturesNames = pd.DataFrame (
    data    = bestFeaturesNames, 
    index   = ['skb', 'ig', 'anova', 'sfs', 'etc', 'rf', 'rfe'],  
    columns = ['Importance_' + str(i) for i in range(1, bestFeaturesNames[1].shape[0] +  1)]
)

# Exibindo DataFrame, com as features ordenadas segundo seu nível de importância.
bestFeaturesNames
Out[126]:
Importance_1 Importance_2 Importance_3 Importance_4 Importance_5 Importance_6 Importance_7 Importance_8 Importance_9
skb account_length number_vmail_messages total_day_minutes total_eve_minutes total_night_minutes total_intl_minutes total_intl_calls number_customer_service_calls international_plan_dummy
ig total_day_minutes number_customer_service_calls international_plan_dummy number_vmail_messages state_dummy total_day_calls total_intl_calls account_length total_eve_minutes
anova number_vmail_messages total_day_minutes total_day_calls total_eve_minutes total_night_minutes total_intl_minutes total_intl_calls number_customer_service_calls international_plan_dummy
sfs number_vmail_messages total_day_minutes total_eve_minutes total_eve_calls total_night_minutes total_intl_minutes total_intl_calls number_customer_service_calls international_plan_dummy
etc total_day_minutes number_customer_service_calls total_eve_minutes total_intl_calls international_plan_dummy total_intl_minutes total_night_minutes total_day_calls account_length
rf total_day_minutes number_customer_service_calls total_eve_minutes international_plan_dummy total_intl_minutes total_intl_calls total_night_minutes account_length total_day_calls
rfe number_vmail_messages total_day_minutes total_day_calls total_eve_minutes total_night_minutes total_intl_minutes total_intl_calls number_customer_service_calls international_plan_dummy
In [127]:
# Contabilizando o número de ocorrências de cada uma das features dentro do DataFrame.
bestFeaturesNames.melt().value.value_counts()
Out[127]:
total_intl_calls                 7
total_eve_minutes                7
international_plan_dummy         7
total_day_minutes                7
number_customer_service_calls    7
total_intl_minutes               6
total_night_minutes              6
total_day_calls                  5
number_vmail_messages            5
account_length                   4
total_eve_calls                  1
state_dummy                      1
Name: value, dtype: int64
In [128]:
# Salvando o DataFrame, com as melhores variáveis selecionadas, pelas técnicas de Feature Selection utilizadas.
bestFeaturesNames.to_csv('outputs/bestFeaturesNames.csv')

6. Modelagem Preditiva

6.1 Criando modelos preditivos e avaliando suas Performances

Iremos criar modelos preditivos, com diferentes algoritmos, e com as Features em diferentes escalas. Também criaremos classificadores utilizando a técnica PCA. Por fim, selecionaremos os modelos que obtiveram as maiores acurácias.

6.1.1 Treinando modelos a partir dos componentes criados pela técnica PCA.

In [129]:
# Treinando classificadores, a partir dos componentes criados pela técnica PCA.
resultsPCA = utlml.classifiersTraining (
    features = trainFeaturesPCA, 
    tTarget  = trainTarget
)
LR: 0.855065 (0.028572)
LDA: 0.855073 (0.018841)
KNN: 0.881478 (0.024361)
CART: 0.878486 (0.009993)
RF: 0.918685 (0.020885)
XGBoost: 0.911789 (0.016463)
In [130]:
# Plotando os scores, da acurácia dos classificadores treinados, em boxplots.
utlex.plotBoxplot(data = resultsPCA[0])

O algoritmo XGBoost, foi o que obteve a melhor acurácia, para o conjunto de componentes do PCA.

6.1.2 Treinando modelos com as Features transformadas pelo algoritmo MinMaxScaler

In [131]:
# Carregando o DataFrame, com as variáveis selecionadas, por cada uma das técnicas de Feature Selection.
bestFeaturesNames = pd.read_csv('outputs/bestFeaturesNames.csv', index_col = 0)
In [132]:
# Treinando classificadores, a partir da escala, e da técnica de Feature Selection utilizada.
resultsMMSkb = utlml.classifiersTraining (
    features = trainFeaturesMM[list(bestFeaturesNames.loc['skb'])], 
    tTarget  = trainTarget
)
LR: 0.861667 (0.023142)
LDA: 0.855064 (0.023529)
KNN: 0.905781 (0.019137)
CART: 0.919893 (0.014891)
RF: 0.954692 (0.016478)
XGBoost: 0.958593 (0.011929)
In [133]:
# Plotando os scores, da acurácia dos classificadores treinados, em boxplots.

utlex.plotBoxplot(data = resultsMMSkb[0])
In [134]:
# Treinando classificadores, a partir da escala, e da técnica de Feature Selection utilizada.
resultsMMIg = utlml.classifiersTraining (
    features = trainFeaturesMM[list(bestFeaturesNames.loc['ig'])], 
    tTarget  = trainTarget
)
LR: 0.859566 (0.022645)
LDA: 0.852067 (0.023894)
KNN: 0.885975 (0.017484)
CART: 0.892289 (0.016361)
RF: 0.936084 (0.014437)
XGBoost: 0.935484 (0.015647)
In [135]:
# Plotando os scores, da acurácia dos classificadores treinados, em boxplots.

utlex.plotBoxplot(data = resultsMMIg[0])
In [136]:
# Treinando classificadores, a partir da escala, e da técnica de Feature Selection utilizada.
resultsMMAnova = utlml.classifiersTraining (
    features = trainFeaturesMM[list(bestFeaturesNames.loc['anova'])], 
    tTarget  = trainTarget
)
LR: 0.861966 (0.024231)
LDA: 0.854766 (0.022182)
KNN: 0.908471 (0.020659)
CART: 0.917498 (0.018288)
RF: 0.955294 (0.016360)
XGBoost: 0.957092 (0.013837)
In [137]:
# Plotando os scores, da acurácia dos classificadores treinados, em boxplots.
utlex.plotBoxplot(data = resultsMMAnova[0])
In [138]:
# Treinando classificadores, a partir da escala, e da técnica de Feature Selection utilizada.
resultsMMSfs = utlml.classifiersTraining (
    features = trainFeaturesMM[list(bestFeaturesNames.loc['sfs'])], 
    tTarget  = trainTarget
)
LR: 0.861668 (0.023716)
LDA: 0.856265 (0.023269)
KNN: 0.909072 (0.021839)
CART: 0.914497 (0.019257)
RF: 0.955592 (0.016162)
XGBoost: 0.960092 (0.012466)
In [139]:
# Plotando os scores, da acurácia dos classificadores treinados, em boxplots.
utlex.plotBoxplot(data = resultsMMSfs[0])
In [140]:
# Treinando classificadores, a partir da escala, e da técnica de Feature Selection utilizada.
resultsMMEtc = utlml.classifiersTraining (
    features = trainFeaturesMM[list(bestFeaturesNames.loc['etc'])], 
    tTarget  = trainTarget
)
LR: 0.859568 (0.024512)
LDA: 0.850568 (0.022600)
KNN: 0.891376 (0.021537)
CART: 0.897389 (0.010733)
RF: 0.936992 (0.016394)
XGBoost: 0.936094 (0.015424)
In [141]:
# Plotando os scores, da acurácia dos classificadores treinados, em boxplots.
utlex.plotBoxplot(data = resultsMMEtc[0])
In [142]:
# Treinando classificadores, a partir da escala, e da técnica de Feature Selection utilizada.
resultsMMRfe = utlml.classifiersTraining (
    features = trainFeaturesMM[list(bestFeaturesNames.loc['rfe'])], 
    tTarget  = trainTarget
)
LR: 0.861966 (0.024231)
LDA: 0.854766 (0.022182)
KNN: 0.908471 (0.020659)
CART: 0.919894 (0.017552)
RF: 0.958287 (0.018925)
XGBoost: 0.957092 (0.013837)
In [143]:
# Plotando os scores, da acurácia dos classificadores treinados, em boxplots.
utlex.plotBoxplot(data = resultsMMRfe[0])

6.1.2.1 Avaliando os resultados dos modelos com as Features transformadas pelo algoritmo MinMaxScaler

In [144]:
# Criando uma lista, com todos os resultados considerando os dados transformados pelo algoritmo MinMaxScaler.
bestResultsMM = [pd.DataFrame(resultsPCA[1])['mean'].values,
                 pd.DataFrame(resultsMMSkb[1])['mean'].values,
                 pd.DataFrame(resultsMMIg[1])['mean'].values,
                 pd.DataFrame(resultsMMAnova[1])['mean'].values,
                 pd.DataFrame(resultsMMSfs[1])['mean'].values,
                 pd.DataFrame(resultsMMEtc[1])['mean'].values,
                 pd.DataFrame(resultsMMRfe[1])['mean'].values]

# Convertendo a lista, para um DataFrame, com os resultados organizados.
bestResultsMM = pd.DataFrame (
    data    = [ sorted(a) for a in bestResultsMM], 
    index   = ['resultsPCA' ,'resultsMMSkb','resultsMMIg','resultsMMAnova','resultsMMSfs','resultsMMEtc','resultsMMRfe'],  
    columns = [ str(i) for i in pd.DataFrame(resultsPCA[0]).columns]#'LR', 'LDA', 'KNN', 'CART', 'RF', 'XGBoost']
)

# Exibindo DataFrame, com os resultados considerando os dados transformados pelo algoritmo MinMaxScaler..
bestResultsMM.sort_values(by = 'XGBoost', ascending = False)
Out[144]:
LR LDA KNN CART RF XGBoost
resultsMMSfs 0.856265 0.861668 0.909072 0.914497 0.955592 0.960092
resultsMMSkb 0.855064 0.861667 0.905781 0.919893 0.954692 0.958593
resultsMMRfe 0.854766 0.861966 0.908471 0.919894 0.957092 0.958287
resultsMMAnova 0.854766 0.861966 0.908471 0.917498 0.955294 0.957092
resultsMMEtc 0.850568 0.859568 0.891376 0.897389 0.936094 0.936992
resultsMMIg 0.852067 0.859566 0.885975 0.892289 0.935484 0.936084
resultsPCA 0.855065 0.855073 0.878486 0.881478 0.911789 0.918685

Os algoritmos RandomForest e XGBoost, foram os que obteveram a melhor acurácia, para o conjunto dados transformados pelo algoritmo MinMaxScaler, em praticamente todos os grupos de Features gerados.

6.1.3 Treinando modelos com as Features transformadas pelo algoritmo StandScaler

In [145]:
# Treinando classificadores, a partir da escala, e da técnica de Feature Selection utilizada.
resultsSSSkb = utlml.classifiersTraining (
    features = trainFeaturesStandScaler[list(bestFeaturesNames.loc['skb'])], 
    tTarget  = trainTarget
)
LR: 0.863469 (0.021838)
LDA: 0.855064 (0.023529)
KNN: 0.904580 (0.016920)
CART: 0.923192 (0.015135)
RF: 0.956493 (0.018080)
XGBoost: 0.958593 (0.011929)
In [146]:
# Plotando os scores, da acurácia dos classificadores treinados, em boxplots.
utlex.plotBoxplot(data = resultsSSSkb[0])
In [147]:
# Treinando classificadores, a partir da escala, e da técnica de Feature Selection utilizada.
resultsSSIg = utlml.classifiersTraining (
    features = trainFeaturesStandScaler[list(bestFeaturesNames.loc['ig'])], 
    tTarget  = trainTarget
)
LR: 0.857163 (0.022756)
LDA: 0.852067 (0.023894)
KNN: 0.897073 (0.022456)
CART: 0.891079 (0.020937)
RF: 0.936086 (0.014921)
XGBoost: 0.935784 (0.015352)
In [148]:
# Plotando os scores, da acurácia dos classificadores treinados, em boxplots.
utlex.plotBoxplot(data = resultsSSIg[0])
In [149]:
# Treinando classificadores, a partir da escala, e da técnica de Feature Selection utilizada.
resultsSSAnova = utlml.classifiersTraining (
    features = trainFeaturesStandScaler[list(bestFeaturesNames.loc['anova'])], 
    tTarget  = trainTarget
)
LR: 0.861670 (0.020077)
LDA: 0.854766 (0.022182)
KNN: 0.903375 (0.017310)
CART: 0.918985 (0.018331)
RF: 0.957693 (0.017329)
XGBoost: 0.957092 (0.013837)
In [150]:
# Plotando os scores, da acurácia dos classificadores treinados, em boxplots.
utlex.plotBoxplot(data = resultsSSAnova[0])
In [151]:
# Treinando classificadores, a partir da escala, e da técnica de Feature Selection utilizada.
resultsSSSfs = utlml.classifiersTraining (
    features = trainFeaturesStandScaler[list(bestFeaturesNames.loc['sfs'])], 
    tTarget  = trainTarget
)
LR: 0.863170 (0.021875)
LDA: 0.856265 (0.023269)
KNN: 0.906670 (0.022108)
CART: 0.914797 (0.018536)
RF: 0.955290 (0.017280)
XGBoost: 0.960092 (0.012466)
In [152]:
# Plotando os scores, da acurácia dos classificadores treinados, em boxplots.
utlex.plotBoxplot(data = resultsSSSfs[0])
In [153]:
# Treinando classificadores, a partir da escala, e da técnica de Feature Selection utilizada.
resultsSSEtc = utlml.classifiersTraining (
    features = trainFeaturesStandScaler[list(bestFeaturesNames.loc['etc'])], 
    tTarget  = trainTarget
)
LR: 0.858368 (0.023917)
LDA: 0.850568 (0.022600)
KNN: 0.887778 (0.022244)
CART: 0.897690 (0.011964)
RF: 0.939092 (0.015668)
XGBoost: 0.936394 (0.015053)
In [154]:
# Plotando os scores, da acurácia dos classificadores treinados, em boxplots.
utlex.plotBoxplot(data = resultsSSEtc[0])
In [155]:
# Treinando classificadores, a partir da escala, e da técnica de Feature Selection utilizada.
resultsSSRfe = utlml.classifiersTraining (
    features = trainFeaturesStandScaler[list(bestFeaturesNames.loc['rfe'])], 
    tTarget  = trainTarget
)
LR: 0.861670 (0.020077)
LDA: 0.854766 (0.022182)
KNN: 0.903375 (0.017310)
CART: 0.920488 (0.016089)
RF: 0.955291 (0.017435)
XGBoost: 0.957092 (0.013837)
In [156]:
# Plotando os scores, da acurácia dos classificadores treinados, em boxplots.
utlex.plotBoxplot(data = resultsSSRfe[0])

6.1.3.1 Avaliando os resultados dos modelos com as Features transformadas pelo algoritmo StandScaler

In [157]:
# Criando uma lista, com todos os resultados considerando os dados transformados pelo algoritmo StandardScaler.
bestResultsSS = [pd.DataFrame(resultsSSSkb[1])['mean'].values,
                 pd.DataFrame(resultsSSIg[1])['mean'].values,
                 pd.DataFrame(resultsSSAnova[1])['mean'].values,
                 pd.DataFrame(resultsSSSfs[1])['mean'].values,
                 pd.DataFrame(resultsSSEtc[1])['mean'].values,
                 pd.DataFrame(resultsSSRfe[1])['mean'].values]

# Convertendo a lista, para um DataFrame, com os resultados organizados.
bestResultsSS = pd.DataFrame (
    data    = [ sorted(a) for a in bestResultsSS], 
    index   = ['resultsSSSkb','resultsSSIg','resultsSSAnova','resultsSSSfs','resultsSSEtc','resultsSSRfe'],  
    columns = [ str(i) for i in pd.DataFrame(resultsSSSkb[0]).columns]
)

# Exibindo DataFrame, com os resultados considerando os dados transformados pelo algoritmo StandardScaler..
bestResultsSS.sort_values(by = 'XGBoost', ascending = False)
Out[157]:
LR LDA KNN CART RF XGBoost
resultsSSSfs 0.856265 0.863170 0.906670 0.914797 0.955290 0.960092
resultsSSSkb 0.855064 0.863469 0.904580 0.923192 0.956493 0.958593
resultsSSAnova 0.854766 0.861670 0.903375 0.918985 0.957092 0.957693
resultsSSRfe 0.854766 0.861670 0.903375 0.920488 0.955291 0.957092
resultsSSEtc 0.850568 0.858368 0.887778 0.897690 0.936394 0.939092
resultsSSIg 0.852067 0.857163 0.891079 0.897073 0.935784 0.936086

Os algoritmos RandomForest e XGBoost, foram os que obteveram a melhor acurácia, para o conjunto dados transformados pelo algoritmo StandardScaler, em praticamente todos os grupos de Features gerados.

6.1.4 Treinando modelos com as Features transformadas pelo algoritmo Box-Cox

In [158]:
# Treinando classificadores, a partir da escala, e da técnica de Feature Selection utilizada.
resultsNDSkb = utlml.classifiersTraining (
    features = trainFeaturesNormDistribuition[list(bestFeaturesNames.loc['skb'])], 
    tTarget  = trainTarget
)
LR: 0.867969 (0.022479)
LDA: 0.859267 (0.023259)
KNN: 0.893178 (0.020775)
CART: 0.921988 (0.016942)
RF: 0.955289 (0.018491)
XGBoost: 0.958593 (0.011929)
In [159]:
# Plotando os scores, da acurácia dos classificadores treinados, em boxplots.
utlex.plotBoxplot(data = resultsNDSkb[0])
In [160]:
# Treinando classificadores, a partir da escala, e da técnica de Feature Selection utilizada.
resultsNDIg = utlml.classifiersTraining (
    features = trainFeaturesNormDistribuition[list(bestFeaturesNames.loc['ig'])], 
    tTarget  = trainTarget
)
LR: 0.862266 (0.022987)
LDA: 0.852667 (0.023376)
KNN: 0.888974 (0.018088)
CART: 0.891989 (0.012740)
RF: 0.934284 (0.018264)
XGBoost: 0.935184 (0.015931)
In [161]:
# Plotando os scores, da acurácia dos classificadores treinados, em boxplots.
utlex.plotBoxplot(data = resultsNDIg[0])
In [162]:
# Treinando classificadores, a partir da escala, e da técnica de Feature Selection utilizada.
resultsNDAnova = utlml.classifiersTraining (
    features = trainFeaturesNormDistribuition[list(bestFeaturesNames.loc['anova'])], 
    tTarget  = trainTarget
)
LR: 0.868570 (0.022667)
LDA: 0.859268 (0.022705)
KNN: 0.887770 (0.023457)
CART: 0.918089 (0.014414)
RF: 0.956492 (0.016194)
XGBoost: 0.957092 (0.013837)
In [163]:
# Plotando os scores, da acurácia dos classificadores treinados, em boxplots.
utlex.plotBoxplot(data = resultsNDAnova[0])
In [164]:
# Treinando classificadores, a partir da escala, e da técnica de Feature Selection utilizada.
resultsNDSfs = utlml.classifiersTraining (
    features = trainFeaturesNormDistribuition[list(bestFeaturesNames.loc['sfs'])], 
    tTarget  = trainTarget
)
LR: 0.866768 (0.023816)
LDA: 0.858667 (0.023141)
KNN: 0.896475 (0.026509)
CART: 0.916596 (0.020426)
RF: 0.955290 (0.017998)
XGBoost: 0.960092 (0.012466)
In [165]:
# Plotando os scores, da acurácia dos classificadores treinados, em boxplots.
utlex.plotBoxplot(data = resultsNDSfs[0])
In [166]:
# Treinando classificadores, a partir da escala, e da técnica de Feature Selection utilizada.
resultsNDEtc = utlml.classifiersTraining (
    features = trainFeaturesNormDistribuition[list(bestFeaturesNames.loc['etc'])], 
    tTarget  = trainTarget
)
LR: 0.862269 (0.024496)
LDA: 0.853569 (0.022717)
KNN: 0.877878 (0.022994)
CART: 0.898591 (0.012497)
RF: 0.936088 (0.015568)
XGBoost: 0.936993 (0.015423)
In [167]:
# Plotando os scores, da acurácia dos classificadores treinados, em boxplots.
utlex.plotBoxplot(data = resultsNDEtc[0])
In [168]:
# Treinando classificadores, a partir da escala, e da técnica de Feature Selection utilizada.
resultsNDRfe = utlml.classifiersTraining (
    features = trainFeaturesNormDistribuition[list(bestFeaturesNames.loc['rfe'])], 
    tTarget  = trainTarget
)
LR: 0.868570 (0.022667)
LDA: 0.859268 (0.022705)
KNN: 0.887770 (0.023457)
CART: 0.920195 (0.015131)
RF: 0.956191 (0.017524)
XGBoost: 0.957092 (0.013837)
In [169]:
# Plotando os scores, da acurácia dos classificadores treinados, em boxplots.
utlex.plotBoxplot(data = resultsNDRfe[0])

6.1.4.1 Avaliando os resultados dos modelos com as Features transformadas pelo algoritmo Box-Cox

In [170]:
# Criando uma lista, com todos os resultados considerando os dados transformados pelo algoritmo Box-Cox.
bestResultsND = [pd.DataFrame(resultsNDSkb[1])['mean'].values,
                 pd.DataFrame(resultsNDIg[1])['mean'].values,
                 pd.DataFrame(resultsNDAnova[1])['mean'].values,
                 pd.DataFrame(resultsNDSfs[1])['mean'].values,
                 pd.DataFrame(resultsNDEtc[1])['mean'].values,
                 pd.DataFrame(resultsNDRfe[1])['mean'].values]

# Convertendo a lista, para um DataFrame, com os resultados organizados.
bestResultsND = pd.DataFrame (
    data    = [ sorted(a) for a in bestResultsND], 
    index   = ['resultsNDSkb','resultsNDIg','resultsNDAnova','resultsNDSfs','resultsNDEtc','resultsNDRfe'],  
    columns = [ str(i) for i in pd.DataFrame(resultsNDSkb[0]).columns]
)

# Exibindo DataFrame, com os resultados considerando os dados transformados pelo algoritmo Box-Cox.
bestResultsND.sort_values(by = 'XGBoost', ascending = False)
Out[170]:
LR LDA KNN CART RF XGBoost
resultsNDSfs 0.858667 0.866768 0.896475 0.916596 0.955290 0.960092
resultsNDSkb 0.859267 0.867969 0.893178 0.921988 0.955289 0.958593
resultsNDAnova 0.859268 0.868570 0.887770 0.918089 0.956492 0.957092
resultsNDRfe 0.859268 0.868570 0.887770 0.920195 0.956191 0.957092
resultsNDEtc 0.853569 0.862269 0.877878 0.898591 0.936088 0.936993
resultsNDIg 0.852667 0.862266 0.888974 0.891989 0.934284 0.935184

Os algoritmos RandomForest e XGBoost, foram os que obteveram a melhor acurácia, para o conjunto dados transformados pelo algoritmo Box-Cox, em praticamente todos os grupos de Features gerados.

6.1.5 Treinando modelos com as Features Normalizadas

In [171]:
# Treinando classificadores, a partir da escala, e da técnica de Feature Selection utilizada.
resultsNSkb = utlml.classifiersTraining (
    features = trainFeaturesNormalized[list(bestFeaturesNames.loc['skb'])], 
    tTarget  = trainTarget
)
LR: 0.855065 (0.028572)
LDA: 0.849961 (0.027000)
KNN: 0.843368 (0.024178)
CART: 0.875472 (0.022138)
RF: 0.910583 (0.016675)
XGBoost: 0.925582 (0.018087)
In [172]:
# Plotando os scores, da acurácia dos classificadores treinados, em boxplots.
utlex.plotBoxplot(data = resultsNSkb[0])
In [173]:
# Treinando classificadores, a partir da escala, e da técnica de Feature Selection utilizada.
resultsNIg = utlml.classifiersTraining (
    features = trainFeaturesNormalized[list(bestFeaturesNames.loc['ig'])], 
    tTarget  = trainTarget
)
LR: 0.855065 (0.028572)
LDA: 0.849362 (0.027060)
KNN: 0.839164 (0.028520)
CART: 0.859573 (0.018235)
RF: 0.900980 (0.019405)
XGBoost: 0.918688 (0.016036)
In [174]:
# Plotando os scores, da acurácia dos classificadores treinados, em boxplots.
utlex.plotBoxplot(data = resultsNIg[0])
In [175]:
# Treinando classificadores, a partir da escala, e da técnica de Feature Selection utilizada.
resultsNAnova = utlml.classifiersTraining (
    features = trainFeaturesNormalized[list(bestFeaturesNames.loc['anova'])], 
    tTarget  = trainTarget
)
LR: 0.855065 (0.028572)
LDA: 0.849662 (0.027246)
KNN: 0.849669 (0.022459)
CART: 0.881478 (0.018125)
RF: 0.911181 (0.017185)
XGBoost: 0.926185 (0.017327)
In [176]:
# Plotando os scores, da acurácia dos classificadores treinados, em boxplots.
utlex.plotBoxplot(data = resultsNAnova[0])
In [177]:
# Treinando classificadores, a partir da escala, e da técnica de Feature Selection utilizada.
resultsNSfs = utlml.classifiersTraining (
    features = trainFeaturesNormalized[list(bestFeaturesNames.loc['sfs'])], 
    tTarget  = trainTarget
)
LR: 0.855065 (0.028572)
LDA: 0.848762 (0.025137)
KNN: 0.852071 (0.023990)
CART: 0.873993 (0.020989)
RF: 0.911482 (0.018118)
XGBoost: 0.927389 (0.013551)
In [178]:
# Plotando os scores, da acurácia dos classificadores treinados, em boxplots.
utlex.plotBoxplot(data = resultsNSfs[0])
In [179]:
# Treinando classificadores, a partir da escala, e da técnica de Feature Selection utilizada.
resultsNEtc = utlml.classifiersTraining (
    features = trainFeaturesNormalized[list(bestFeaturesNames.loc['etc'])], 
    tTarget  = trainTarget
)
LR: 0.855065 (0.028572)
LDA: 0.846069 (0.022523)
KNN: 0.837971 (0.024902)
CART: 0.853878 (0.024850)
RF: 0.903986 (0.016021)
XGBoost: 0.906089 (0.019958)
In [180]:
# Plotando os scores, da acurácia dos classificadores treinados, em boxplots.
utlex.plotBoxplot(data = resultsNEtc[0])
In [181]:
# Treinando classificadores, a partir da escala, e da técnica de Feature Selection utilizada.
resultsNRfe = utlml.classifiersTraining (
    features = trainFeaturesNormalized[list(bestFeaturesNames.loc['rfe'])], 
    tTarget  = trainTarget
)
LR: 0.855065 (0.028572)
LDA: 0.849662 (0.027246)
KNN: 0.849669 (0.022459)
CART: 0.878184 (0.015034)
RF: 0.913584 (0.016234)
XGBoost: 0.926185 (0.017327)
In [182]:
# Plotando os scores, da acurácia dos classificadores treinados, em boxplots.
utlex.plotBoxplot(data = resultsNRfe[0])

6.1.5.1 Avaliando os resultados dos modelos com as Features Normalizadas

In [183]:
# Criando uma lista, com todos os resultados considerando os dados transformados pelo algoritmo normalize.
bestResultsN = [pd.DataFrame(resultsNSkb[1])['mean'].values,
                 pd.DataFrame(resultsNIg[1])['mean'].values,
                 pd.DataFrame(resultsNAnova[1])['mean'].values,
                 pd.DataFrame(resultsNSfs[1])['mean'].values,
                 pd.DataFrame(resultsNEtc[1])['mean'].values,
                 pd.DataFrame(resultsNRfe[1])['mean'].values]

# Convertendo a lista, para um DataFrame, com os resultados organizados.
bestResultsN = pd.DataFrame (
    data    = [ sorted(a) for a in bestResultsN], 
    index   = ['resultsNRSkb','resultsNIg','resultsNAnova','resultsNSfs','resultsNEtc','resultsNRfe'],  
    columns = [ str(i) for i in pd.DataFrame(resultsNSkb[0]).columns]
)

# Exibindo DataFrame, com os resultados considerando os dados transformados pelo algoritmo normalize.
bestResultsN.sort_values(by = 'XGBoost', ascending = False)
Out[183]:
LR LDA KNN CART RF XGBoost
resultsNSfs 0.848762 0.852071 0.855065 0.873993 0.911482 0.927389
resultsNAnova 0.849662 0.849669 0.855065 0.881478 0.911181 0.926185
resultsNRfe 0.849662 0.849669 0.855065 0.878184 0.913584 0.926185
resultsNRSkb 0.843368 0.849961 0.855065 0.875472 0.910583 0.925582
resultsNIg 0.839164 0.849362 0.855065 0.859573 0.900980 0.918688
resultsNEtc 0.837971 0.846069 0.853878 0.855065 0.903986 0.906089

Os algoritmos RandomForest e XGBoost, foram os que obteveram a melhor acurácia, para o conjunto dados transformados pelo algoritmo normalize, em praticamente todos os grupos de Features gerados.

6.1.6 Avaliação final dos resultados dos melhores modelos.

In [184]:
bestResultsMM.iloc[:,4:6].sort_values(by = 'XGBoost', ascending = False)
Out[184]:
RF XGBoost
resultsMMSfs 0.955592 0.960092
resultsMMSkb 0.954692 0.958593
resultsMMRfe 0.957092 0.958287
resultsMMAnova 0.955294 0.957092
resultsMMEtc 0.936094 0.936992
resultsMMIg 0.935484 0.936084
resultsPCA 0.911789 0.918685
In [185]:
bestResultsSS.iloc[:,4:6].sort_values(by = 'XGBoost', ascending = False)
Out[185]:
RF XGBoost
resultsSSSfs 0.955290 0.960092
resultsSSSkb 0.956493 0.958593
resultsSSAnova 0.957092 0.957693
resultsSSRfe 0.955291 0.957092
resultsSSEtc 0.936394 0.939092
resultsSSIg 0.935784 0.936086
In [186]:
bestResultsND.iloc[:,4:6].sort_values(by = 'XGBoost', ascending = False)
Out[186]:
RF XGBoost
resultsNDSfs 0.955290 0.960092
resultsNDSkb 0.955289 0.958593
resultsNDAnova 0.956492 0.957092
resultsNDRfe 0.956191 0.957092
resultsNDEtc 0.936088 0.936993
resultsNDIg 0.934284 0.935184
In [187]:
bestResultsN.iloc[:,4:6].sort_values(by = 'XGBoost', ascending = False)
Out[187]:
RF XGBoost
resultsNSfs 0.911482 0.927389
resultsNAnova 0.911181 0.926185
resultsNRfe 0.913584 0.926185
resultsNRSkb 0.910583 0.925582
resultsNIg 0.900980 0.918688
resultsNEtc 0.903986 0.906089

6.2 Realizando previsões para o conjunto de dados de teste

6.2.1 Otimizando Classificadores

Após as analises preliminares, observamos que as features selecionadas pelo algoritmo Sfs foram as que obtiveram a melhor performance. E por isso, iremos utilizá-las nas fases a seguir..

In [188]:
# Listando as siglas, das técnicas de Feature Selection utilizadas.
bestFeaturesNames.index
Out[188]:
Index(['skb', 'ig', 'anova', 'sfs', 'etc', 'rf', 'rfe'], dtype='object')
In [189]:
# Definindo qual resultado, das técnicas de Feature Selection, deve ser utilizado.
f = list(bestFeaturesNames.loc['sfs'])

6.2.2 Aplicando diferentes escalas as Features de teste

Nesta etapa, iremos aplicar diferentes transformações, nas variáveis preditoras dos conjuntos de dados de treino e de teste.

In [190]:
# Aplicando a transformação MinMaxScaler, as Features do conjunto de dados de treino e de teste.
trainFeaturesMM, testFeaturesMM = utlst.dataTransform (
    train     = trainFeatures[f],
    test      = testFeatures[f],
    transform = 'MM'
)
In [191]:
# Aplicando a transformação StandardScaler, as Features do conjunto de dados de treino e de teste.
trainFeaturesSS, testFeaturesSS = utlst.dataTransform (
    train     = trainFeatures[f],
    test      = testFeatures[f],
    transform = 'SS'
)
In [192]:
# Aplicando a transformação Yeo-Johnson, as Features do conjunto de dados de treino e de teste.
trainFeaturesNormDistribuition, testFeaturesNormDistribuition = utlst.dataTransform (
    train     = trainFeatures[f],
    test      = testFeatures[f],
    transform = 'ND'
)
In [193]:
# Aplicando a transformação Normalize, as Features do conjunto de dados de treino e de teste.
trainFeaturesNormalized, testFeaturesNormalized = utlst.dataTransform (
    train     = trainFeatures[f],
    test      = testFeatures[f],
    transform = 'N'
)

6.2.3 Realizando previsões para o conjunto de dados de teste

6.2.3.1 Algoritmo Random Forest

Iremos buscar pelos melhores parâmetros, para criar um modelo com o algoritmo de Random Forest.

In [194]:
# Definindo qual conjunto de dados de treino, já escalado, deve ser utilizado e a sua variável target.
trainX = trainFeaturesSS[f]
trainY = trainTarget

# Definindo qual conjunto de dados de teste, já escalado, deve ser utilizado e a sua variável target.
testX = testFeaturesSS[f]
testY = testTarget

# Definindo os valores que devem ser testados, em cada um dos parâmetros do modelo especificado.
paramGrid = dict (
    n_estimators = list(range(100, 301, 25)), 
    max_depth    = [16, 17, 18]
)

# Criando uma instância da classe do modelo Random Forest.
model = RandomForestClassifier()

# Criando o grid, para fazer a busca dos melhores parâmetros para o modelo.
grid = GridSearchCV(estimator = model, param_grid = paramGrid, cv = 10, verbose = True, n_jobs = -1)

# Buscando pelos melhores parâmetros para o modelo.
grid.fit(trainX, trainY)

# Exibindo a configuração, do melhor modelo treinado.
print("\n" + "Melhores Parâmetros para o Modelo:" + "\n\n", grid.best_estimator_)
Fitting 10 folds for each of 27 candidates, totalling 270 fits

Melhores Parâmetros para o Modelo:

 RandomForestClassifier(max_depth=16, n_estimators=125)
In [195]:
# Criando o modelo, com a melhor configuração encontrada.
classifierRF = grid.best_estimator_

# Treinando o modelo, com os dados de treino.
classifierRF.fit(X = trainX, y = trainY)
Out[195]:
RandomForestClassifier(max_depth=16, n_estimators=125)
In [196]:
# Calculando a acurácia do modelo para o conjunto de dados de treino.
scoreTrainRF = accuracy_score(trainY, classifierRF.predict(trainX))

# Visualizando o resultado.
print('Acurácia para os dados de treino: ' + str(scoreTrainRF))
Acurácia para os dados de treino: 0.993999399939994
In [197]:
# Calculando a acurácia do modelo para o conjunto de dados de teste.
scoreTestRF = accuracy_score(testY, classifierRF.predict(testX))

# Visualizando o resultado.
print('Acurácia  para os dados de teste: ' + str(scoreTestRF))
Acurácia  para os dados de teste: 0.9634073185362927
6.2.3.2 Algoritmo Xgboost

Iremos buscar pelos melhores parâmetros, para criar um modelo com algoritmo Xgboost.

In [198]:
# Definindo qual conjunto de dados de treino, já escalado, deve ser utilizado e a sua variável target.
trainX = trainFeaturesSS[f]
trainY = trainTarget

# Definindo qual conjunto de dados de teste, já escalado, deve ser utilizado e a sua variável target.
testX = testFeaturesSS[f]
testY = testTarget

# Definindo os valores que devem ser testados, em cada um dos parâmetros do modelo especificado.
paramGrid = dict (
    missing          = [np.nan],
    booster          = ['gbtree'],#, 'gblinear', 'dart'],
    max_depth        = [4, 5], 
    n_estimators     = [300, 350], 
    learning_rate    = [0.025, 0.03], 
    nthread          = [4], 
    subsample        = [0.95, 1], 
    colsample_bytree = [0.95, 1], 
    seed             = [100]    
)

# Criando uma instância da classe do modelo Xgboost.
model = xgb.XGBClassifier(use_label_encoder=False,eval_metric='mlogloss')

# Criando o grid, para fazer a busca dos melhores parâmetros para o modelo.
grid = GridSearchCV(estimator = model, param_grid = paramGrid, cv = 10, verbose = True, n_jobs = -1)

# Buscando pelos melhores parâmetros para o modelo.
grid.fit(trainX, trainY)

# Exibindo a configuração, do melhor modelo treinado.
print("\n" + "Melhores Parâmetros para o Modelo:" + "\n\n", grid.best_estimator_)
Fitting 10 folds for each of 32 candidates, totalling 320 fits

Melhores Parâmetros para o Modelo:

 XGBClassifier(base_score=0.5, booster='gbtree', colsample_bylevel=1,
              colsample_bynode=1, colsample_bytree=1, enable_categorical=False,
              eval_metric='mlogloss', gamma=0, gpu_id=-1, importance_type=None,
              interaction_constraints='', learning_rate=0.03, max_delta_step=0,
              max_depth=5, min_child_weight=1, missing=nan,
              monotone_constraints='()', n_estimators=350, n_jobs=4, nthread=4,
              num_parallel_tree=1, predictor='auto', random_state=100,
              reg_alpha=0, reg_lambda=1, scale_pos_weight=1, seed=100,
              subsample=1, tree_method='exact', use_label_encoder=False, ...)
In [199]:
# Criando o modelo, com a melhor configuração encontrada.
classifierXGB = grid.best_estimator_

# Treinando o modelo com os dados de treino.
classifierXGB.fit(X = trainX, y = trainY)
Out[199]:
XGBClassifier(base_score=0.5, booster='gbtree', colsample_bylevel=1,
              colsample_bynode=1, colsample_bytree=1, enable_categorical=False,
              eval_metric='mlogloss', gamma=0, gpu_id=-1, importance_type=None,
              interaction_constraints='', learning_rate=0.03, max_delta_step=0,
              max_depth=5, min_child_weight=1, missing=nan,
              monotone_constraints='()', n_estimators=350, n_jobs=4, nthread=4,
              num_parallel_tree=1, predictor='auto', random_state=100,
              reg_alpha=0, reg_lambda=1, scale_pos_weight=1, seed=100,
              subsample=1, tree_method='exact', use_label_encoder=False, ...)
In [200]:
# Calculando a acurácia do modelo para o conjunto de dados de treino.
scoreTrainXGB = accuracy_score(trainY, classifierXGB.predict(trainX))

# Visualizando o resultado.
print('Acurácia para os dados de treino: ' + str(scoreTrainXGB))
Acurácia para os dados de treino: 0.9795979597959796
In [201]:
# Calculando a acurácia do modelo para o conjunto de dados de teste.
scoreTestXGB = accuracy_score(testY, classifierXGB.predict(testX))

# Visualizando o resultado.
print('Acurácia  para os dados de teste: ' + str(scoreTestXGB))
Acurácia  para os dados de teste: 0.9640071985602879

6.2.4 Avaliando as métricas do melhor classificador para os dados de teste

O melhor classificador treinado, utiliza o algoritmo XGBoost com as features transformadas pelo algoritmo StandScaler. Salvaremos as configurações desse modelo em um arquivo .sav.

In [202]:
# Salvando o modelo preditivo especificado.
utlml.saveModel(name = 'classifierXGB', model = classifierXGB)
Modelo salvo!
In [203]:
# Carregando o modelo preditivo especificado.
classifierXGB = utlml.loadModel(name = 'classifierXGB')
Modelo carregado!

Para analisar melhor a performance do modelo, precisamos determinar os valores das probabilidades geradas nas previsões.

In [204]:
# Definindo qual conjunto de dados de treino, já escalado, deve ser utilizado e a sua variável target.
trainX = trainFeaturesSS[f]
testX  = testFeaturesSS[f]

# Realizando as predições das probabilidades, dos dados de treino e teste, para o modelo selecionado.
predTrainProb = classifierXGB.predict_proba(trainX)[:,1]
predTestProb  = classifierXGB.predict_proba(testX)[:,1]

Iremos binarizar as previsões, e os valores a serem previstos, dos conjuntos de dados de treino e teste.

In [205]:
# Definindo as classes positiva e negativa da variável target.
labelPositive = 'Yes'
labelNegative = 'No'

# Criando uma lista com as categorias das classes.
labels = [labelPositive, labelNegative]

# Convertendo dados da variável target, dos dados de treino, para utilizar as labels especificadas.
trainTargetLabels = [labelPositive if t == 1 else labelNegative for t in trainTarget]
trainPredLabels   = [labelPositive if t >= 0.5 else labelNegative for t in predTrainProb]

# Convertendo dados da variável target, dos dados de teste, para utilizar as labels especificadas.
testTargetLabels = [labelPositive if t == 1 else labelNegative for t in testTarget]
testPredLabels   = [labelPositive if t >= 0.5 else labelNegative for t in predTestProb]
In [206]:
# Criando uma Confusion Matrix para avaliar as previsões feitas para os dados de treino.
cm = utlml.confusionMatrix(yTrue = trainTargetLabels, yPred = trainPredLabels)

# Exibindo a Confusion Matrix.
cm
Out[206]:
Actual Yes No classError
Predicted
Yes 415 0 0.000000
No 68 2850 0.023304

Podemos observar, que o modelo só apresenta falsos negativos para o conjunto de dados de treino. Isto é, o modelo tende a classificar indivíduos que realizaram o churn, como não o tendo feito.

In [207]:
# Criando uma Confusion Matrix para avaliar as previsões feitas para os dados de teste.
cm = utlml.confusionMatrix(yTrue = testTargetLabels, yPred = testPredLabels)

# Exibindo a Confusion Matrix.
cm
Out[207]:
Actual Yes No classError
Predicted
Yes 169 5 0.028736
No 55 1438 0.036839

Nos dados de teste, constatamos a ocorrência de falsos positivos, mas a proporção de falsos negativos continua sendo predominante.

In [208]:
# Plotando a Confusion Matrix dos dados de teste em um gráfico.
utlml.plotConfusionMatrix (
    data   = cm.drop(labels= 'classError', axis = 1), 
    labels = labels
)

Vamos calcular algumas estatísticas, baseadas nos resultados gerados pelo modelo, para os dados de teste.

In [209]:
# Calculando os scores de diferentes métricas, com base nas previsões geradas pelo modelo, para os dados de teste.
utlml.getClassificationMetrics(yTrue = testTargetLabels, predProb = predTestProb)
Out[209]:
Metrics
Accuracy 0.964007
95% CI for Accuracy (0.9550651662414594, 0.9729492308791164)
Kappa 0.829176
Recall (Sensitivity) 0.754464
Specificity 0.996535
Pos Pred Value 0.971264
Neg Pred Value 0.963161
Precision 0.971264
Avarage Precision 0.765778
Prevalence 0.134373
Detection Rate 0.10138
Detection Prevalence 0.104379
F1 0.849246
ROC AUC 0.935409
Error 0.035993
95% CI for Error (0.027050769120883604, 0.04493483375854052)
Balanced Accuracy 0.8755
Positive Class Yes

Finalizamos esta análise, concluindo que o algoritmo XGBoost, gerou o modelo com a melhor acurácia. Os scores alcançados para os conjuntos de dados foram:

  • Dados de treino: 0.979597.
  • Dados de teste: 0.964007.